source: indico/indico/MaKaC/webinterface/pages/admins.py @ f9e571

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

[IMP] Improve accesskey/signature and cache system

  • cache stores fossil instead of serialized response
  • https enforcement can be enabled/disabled
  • api key/signature checking can now be configured
  • add request argument to make an authenticated request return only public data
  • Property mode set to 100644
File size: 104.6 KB
Line 
1# -*- coding: utf-8 -*-
2##
3##
4## This file is part of CDS Indico.
5## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 CERN.
6##
7## CDS Indico is free software; you can redistribute it and/or
8## modify it under the terms of the GNU General Public License as
9## published by the Free Software Foundation; either version 2 of the
10## License, or (at your option) any later version.
11##
12## CDS Indico is distributed in the hope that it will be useful, but
13## WITHOUT ANY WARRANTY; without even the implied warranty of
14## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15## General Public License for more details.
16##
17## You should have received a copy of the GNU General Public License
18## along with CDS Indico; if not, write to the Free Software Foundation, Inc.,
19## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
20
21
22from pytz import timezone
23from MaKaC.user import CERNGroup
24from MaKaC.fossils.user import IAvatarFossil
25
26import os
27from MaKaC.common.general import *
28import MaKaC.webinterface.urlHandlers as urlHandlers
29import MaKaC.webinterface.wcomponents as wcomponents
30import MaKaC.webinterface.pages.conferences as conferences
31from MaKaC.webinterface.pages.conferences import WConfModifBadgePDFOptions
32import MaKaC.common.info as info
33import MaKaC.webcast as webcast
34from MaKaC.common.Configuration import Config
35import MaKaC.conference as conference
36import MaKaC.user as user
37from MaKaC.common import utils, timezoneUtils
38from MaKaC.webinterface.common.person_titles import TitlesRegistry
39from MaKaC.webinterface.common.timezones import TimezoneRegistry, DisplayTimezoneRegistry
40from MaKaC.common.Announcement import getAnnoucementMgrInstance
41from MaKaC.webinterface.pages.main import WPMainBase
42from MaKaC.common.pendingQueues import PendingSubmitterReminder, PendingManagerReminder, PendingCoordinatorReminder
43from MaKaC.authentication import AuthenticatorMgr
44from MaKaC import roomMapping
45from MaKaC import domain
46import MaKaC.common.indexes as indexes
47import MaKaC.webinterface.personalization as personalization
48from cgi import escape
49import re
50from MaKaC.i18n import _
51from indico.util.i18n import i18nformat
52from MaKaC.plugins import PluginLoader, PluginsHolder
53
54from MaKaC.common.fossilize import fossilize
55from MaKaC.fossils.modules import INewsItemFossil
56from indico.modules import ModuleHolder
57from MaKaC.errors import MaKaCError
58from MaKaC.conference import ConferenceHolder
59from MaKaC.webinterface.locators import CategoryWebLocator
60
61class WPAdminsBase( WPMainBase ):
62
63    _userData = ['favorite-user-ids']
64
65    def _getSiteArea(self):
66        return "AdministrationArea"
67
68    def getJSFiles(self):
69        return WPMainBase.getJSFiles(self) + \
70               self._includeJSPackage('Admin') + \
71               self._includeJSPackage('Management')
72
73    def _getHeader( self ):
74        """
75        """
76        wc = wcomponents.WHeader( self._getAW() )
77        return wc.getHTML( { "subArea": self._getSiteArea(), \
78                             "loginURL": self._escapeChars(str(self.getLoginURL())),\
79                             "logoutURL": self._escapeChars(str(self.getLogoutURL())), \
80                             "tabControl": self._getTabControl(), \
81                             "loginAsURL": self.getLoginAsURL() } )
82
83    def _createSideMenu(self):
84        self._sideMenu = wcomponents.ManagementSideMenu()
85
86        mainSection = wcomponents.SideMenuSection()
87
88        self._generalSettingsMenuItem = wcomponents.SideMenuItem(_("General settings"),
89            urlHandlers.UHAdminArea.getURL())
90        mainSection.addItem( self._generalSettingsMenuItem)
91
92        self._localdefMenuItem = wcomponents.SideMenuItem(_("Local Definitions"),
93            urlHandlers.UHAdminLocalDefinitions.getURL())
94        mainSection.addItem( self._localdefMenuItem)
95
96        self._usersAndGroupsMenuItem = wcomponents.SideMenuItem(_("Users and Groups"),
97            urlHandlers.UHUserManagement.getURL())
98        mainSection.addItem( self._usersAndGroupsMenuItem)
99
100        self._domainsMenuItem = wcomponents.SideMenuItem(_("IP Domains"),
101            urlHandlers.UHDomains.getURL())
102        mainSection.addItem( self._domainsMenuItem)
103
104        self._roomsMenuItem = wcomponents.SideMenuItem(_("Rooms"),
105            urlHandlers.UHRoomBookingPluginAdmin.getURL())
106        mainSection.addItem( self._roomsMenuItem)
107
108        self._templatesMenuItem = wcomponents.SideMenuItem(_("Templates"),
109            urlHandlers.UHTemplates.getURL())
110        mainSection.addItem( self._templatesMenuItem)
111
112        self._servicesMenuItem = wcomponents.SideMenuItem(_("Services"),
113            urlHandlers.UHWebcast.getURL())
114        mainSection.addItem( self._servicesMenuItem)
115
116        self._pluginsMenuItem = wcomponents.SideMenuItem(_("Plugins"),
117            urlHandlers.UHAdminPlugins.getURL())
118        mainSection.addItem( self._pluginsMenuItem)
119
120        self._homepageMenuItem = wcomponents.SideMenuItem(_("Homepage"),
121            urlHandlers.UHUpdateNews.getURL())
122        mainSection.addItem( self._homepageMenuItem)
123
124        self._systemMenuItem = wcomponents.SideMenuItem(_("System"),
125            urlHandlers.UHAdminsSystem.getURL())
126        mainSection.addItem( self._systemMenuItem)
127
128        self._sideMenu.addSection(mainSection)
129
130
131    def _getBody( self, params ):
132        self._createSideMenu()
133        self._setActiveSideMenuItem()
134
135        self._createTabCtrl()
136        self._setActiveTab()
137
138        frame = WAdminFrame()
139        p = { "body": self._getPageContent( params ),
140              "sideMenu": self._sideMenu.getHTML() }
141
142        return frame.getHTML( p )
143
144    def _getNavigationDrawer(self):
145        return wcomponents.WSimpleNavigationDrawer(_("Server Admin"), urlHandlers.UHAdminArea.getURL, bgColor="white" )
146
147    def _createTabCtrl(self):
148        pass
149
150    def _getTabContent(self):
151        return "nothing"
152
153    def _setActiveTab(self):
154        pass
155
156    def _setActiveSideMenuItem(self):
157        pass
158
159    def _getPageContent(self, params):
160        return "nothing"
161
162class WAdmins(wcomponents.WTemplated):
163
164    def getVars( self ):
165        vars = wcomponents.WTemplated.getVars( self )
166        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
167        vars["title"] = minfo.getTitle()
168        vars["organisation"] = minfo.getOrganisation()
169        vars["supportEmail"] = minfo.getSupportEmail()
170        vars["publicSupportEmail"] = minfo.getPublicSupportEmail()
171        vars["noReplyEmail"] = minfo.getNoReplyEmail()
172        vars["lang"] = minfo.getLang()
173        vars["address"] = ""
174        if minfo.getCity() != "":
175            vars["address"] = minfo.getCity()
176        if minfo.getCountry() != "":
177            if vars["address"] != "":
178                vars["address"] = "%s (%s)"%(vars["address"], minfo.getCountry())
179            else:
180                vars["address"] = "%s"%minfo.getCountry()
181        try:
182            vars["timezone"] = minfo.getTimezone()
183        except:
184            vars["timezone"] = 'UTC'
185        vars["adminList"] = wcomponents.WPrincipalTable().getHTML( minfo.getAdminList().getList(),  None, vars["addAdminsURL"], vars["removeAdminsURL"], selectable=False )
186        vars["systemIconAdmins"] = Config.getInstance().getSystemIconURL( "admin" )
187        iconDisabled = str(Config.getInstance().getSystemIconURL( "disabledSection" ))
188        iconEnabled = str(Config.getInstance().getSystemIconURL( "enabledSection" ))
189        vars["features"] = ""
190        url = urlHandlers.UHAdminSwitchCacheActive.getURL()
191        if minfo.isCacheActive():
192            icon = iconEnabled
193        else:
194            icon = iconDisabled
195        vars["features"] += i18nformat("""<div style="margin-bottom: 5px"><a href="%s"><img src="%s" border="0" alt="Toggle on/off" style="float:left; padding-right: 5px"> _("Cache Indico Pages")</a></div>""") % (str(url), icon)
196        url = urlHandlers.UHAdminSwitchNewsActive.getURL()
197        if minfo.isNewsActive():
198            icon = iconEnabled
199        else:
200            icon = iconDisabled
201        #vars["features"] += i18nformat("""<br><a href="%s"><img src="%s" border="0" alt="Toggle on/off"> _("News Pages") </a>""") % (str(url), icon)
202        #vars["announcement"] = WAnnouncementModif().getHTML( vars )
203        vars["features"] += i18nformat("""<div style="margin-bottom: 5px"><a href="%s"><img src="%s" border="0" style="float:left; padding-right: 5px">_("News Pages")</a></div>""") % (str(url), icon)
204        url = urlHandlers.UHAdminSwitchDebugActive.getURL()
205        if minfo.isDebugActive():
206            icon = iconEnabled
207        else:
208            icon = iconDisabled
209        vars["features"] += i18nformat("""<div style="margin-bottom: 5px"><a href="%s"><img src="%s" border="0" style="float:left; padding-right: 5px">_("Debug")</a></div>""") % (str(url), icon)
210        return vars
211
212
213class WAdminFrame(wcomponents.WTemplated):
214
215    def __init__( self ):
216        pass
217
218    def getVars( self ):
219        vars = wcomponents.WTemplated.getVars( self )
220        vars["imgGestionGrey"] = Config.getInstance().getSystemIconURL( "gestionGrey" )
221        vars["titleTabPixels"] = self.getTitleTabPixels()
222        vars["intermediateVTabPixels"] = self.getIntermediateVTabPixels()
223        return vars
224
225    def getIntermediateVTabPixels( self ):
226        return 0
227
228    def getTitleTabPixels( self ):
229        return 260
230
231class WRBAdminFrame(WAdminFrame):
232    pass
233
234class WPAdmins( WPAdminsBase ):
235
236    def _setActiveSideMenuItem(self):
237        self._generalSettingsMenuItem.setActive()
238
239    def _getPageContent( self, params ):
240        wc = WAdmins()
241        pars = { "GeneralInfoModifURL": urlHandlers.UHGeneralInfoModification.getURL(), \
242                "addAdminsURL": urlHandlers.UHAdminsSelectUsers.getURL(), \
243                "removeAdminsURL": urlHandlers.UHAdminsRemoveUsers.getURL() }
244        return wc.getHTML( pars )
245
246class WPAdminSelectUsers( WPAdmins ):
247
248    def _getPageContent( self, params ):
249        wc = wcomponents.WPrincipalSelection( urlHandlers.UHAdminsSelectUsers.getURL(), forceWithoutExtAuth=False )
250        wc.setTitle( _("Select administrator"))
251        params["addURL"] =  urlHandlers.UHAdminsAddUsers.getURL()
252        html = i18nformat("""<table align="center" width="95%%">
253    <tr>
254       <td class="formTitle"> _("General admin data")</td>
255    </tr>
256    <tr>
257        <td>
258            <br>
259        """)
260        html = "%s%s"%(html,wc.getHTML( params ))
261        return "%s%s"%(html,"""</td></tr></table>""")
262
263class WGeneralInfoModification(wcomponents.WTemplated):
264
265    def getVars( self ):
266        vars = wcomponents.WTemplated.getVars( self )
267        genInfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
268        vars["title"] = genInfo.getTitle()
269        vars["organisation"] = genInfo.getOrganisation()
270        vars["supportEmail"] = genInfo.getSupportEmail()
271        vars["publicSupportEmail"] = genInfo.getPublicSupportEmail()
272        vars["city"] = genInfo.getCity()
273        vars["country"] = genInfo.getCountry()
274        vars["noReplyEmail"] = genInfo.getNoReplyEmail()
275        try:
276            selected_tz = genInfo.getTimezone()
277        except:
278            selected_tz = 'UTC'
279        vars["timezone"]=TimezoneRegistry.getShortSelectItemsHTML(selected_tz)
280        vars["language"]= genInfo.getLang()
281        return vars
282
283
284class WPAdminLocalDefinitions( WPAdminsBase ):
285
286    def __init__(self, rh):
287        WPAdminsBase.__init__(self, rh)
288
289    def __getAvailableTemplates(self):
290        tplDir = Config.getInstance().getTPLDir()
291
292        tplRE = re.compile('^([^\.]+)\.([^\.]+)\.tpl$')
293
294        templates = {}
295
296        fnames = os.listdir(tplDir);
297        for fname in fnames:
298            m = tplRE.match(fname)
299            if m:
300                templates[m.group(2)] = None
301
302        tplRE = re.compile('^([^\.]+)\.([^\.]+)\.wohl$')
303
304        fnames = os.listdir(os.path.join(tplDir,'chelp'));
305        for fname in fnames:
306            m = tplRE.match(fname)
307            if m:
308                templates[m.group(2)] = None
309
310        return templates.keys()
311
312    def _getPageContent( self, params ):
313        wc = WAdminLocalDefinitions()
314        pars = {    "defaultTemplateSet": info.HelperMaKaCInfo.getMaKaCInfoInstance().getDefaultTemplateSet(),
315                    "availableTemplates": self.__getAvailableTemplates(),
316                    "formURL": urlHandlers.UHAdminSaveTemplateSet.getURL() }
317        return wc.getHTML( pars )
318
319    def _setActiveSideMenuItem( self ):
320        self._localdefMenuItem.setActive()
321
322class WAdminLocalDefinitions(wcomponents.WTemplated):
323
324    pass
325
326
327
328class WPGenInfoModification( WPAdmins ):
329
330    def _getPageContent( self, params ):
331        wc = WGeneralInfoModification()
332        pars = { "postURL": urlHandlers.UHGeneralInfoPerformModification.getURL() }
333        return wc.getHTML( pars )
334
335class WPHomepageCommon( WPAdminsBase ):
336    def _setActiveSideMenuItem(self):
337        self._homepageMenuItem.setActive()
338
339    def _createTabCtrl( self ):
340        self._tabCtrl = wcomponents.TabControl()
341
342        self._subTabNews = self._tabCtrl.newTab( "news", _("News"), \
343                urlHandlers.UHUpdateNews.getURL() )
344        self._subTabAnnouncements = self._tabCtrl.newTab( "announcements", _("Announcements"), \
345                urlHandlers.UHAnnouncement.getURL() )
346        self._subTabUpcoming = self._tabCtrl.newTab( "upcoming", _("Upcoming Events"), \
347                urlHandlers.UHConfigUpcomingEvents.getURL() )
348
349    def _getPageContent(self, params):
350        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
351
352class WPUpdateNews( WPHomepageCommon ):
353
354    def _setActiveTab( self ):
355        self._subTabNews.setActive()
356
357    def _getTabContent( self, params ):
358        tz = timezone(timezoneUtils.DisplayTZ(self._getAW()).getDisplayTZ())
359        wc = WUpdateNews()
360        newsModule = ModuleHolder().getById("news")
361
362        newslist = fossilize(newsModule.getNewsItemsList(), INewsItemFossil, tz=tz)
363        newsTypesList = newsModule.getNewsTypesAsDict()
364        recentDays = newsModule.getRecentDays()
365
366        pars = {"newslist": newslist,
367                "newsTypesList": newsTypesList,
368                "recentDays": recentDays }
369
370        return wc.getHTML( pars )
371
372class WUpdateNews(wcomponents.WTemplated):
373
374    def getVars( self ):
375        vars = wcomponents.WTemplated.getVars( self )
376        vars["baseURL"] = Config.getInstance().getBaseURL()
377        vars["postURL"] = urlHandlers.UHUpdateNews.getURL()
378        return vars
379
380class WPConfigUpcomingEvents( WPHomepageCommon ):
381
382    def _setActiveTab( self ):
383        self._subTabUpcoming.setActive()
384
385    def _getTabContent( self, params ):
386        wc = WConfigUpcomingEvents()
387        pars = {}
388        return wc.getHTML( pars )
389
390class WConfigUpcomingEvents(wcomponents.WTemplated):
391
392    def getVars( self ):
393        vars = wcomponents.WTemplated.getVars( self )
394        return vars
395
396
397class WPAnnouncementModif( WPHomepageCommon ):
398
399    def _setActiveTab( self ):
400        self._subTabAnnouncements.setActive()
401
402    def _getTabContent( self, params ):
403        wc = WAnnouncementModif()
404        pars = {"saveURL": urlHandlers.UHAnnouncementSave.getURL() }
405        return wc.getHTML( pars )
406
407class WAnnouncementModif(wcomponents.WTemplated):
408
409    def getVars(self):
410        vars = wcomponents.WTemplated.getVars(self)
411        an = getAnnoucementMgrInstance()
412        vars["announcement"] = escape(an.getText()).replace("\"", "&#34;")
413        return vars
414
415
416class WPAdminPlugins( WPAdminsBase ):
417
418    _userData = ['favorite-user-list', 'favorite-user-ids']
419
420    def __init__(self, rh, pluginTypeId, initialPlugin):
421        WPAdminsBase.__init__(self, rh)
422        self._pluginTypeId = pluginTypeId
423        self._initialPlugin = initialPlugin
424        self._user = rh._getUser()
425        self._tabs = {}
426
427    def _createTabCtrl(self):
428        self._tabCtrl = wcomponents.TabControl()
429
430        self._tabs["Main"] = self._tabCtrl.newTab("Main", _("Main"), urlHandlers.UHAdminPlugins.getURL())
431
432        pluginTypes = PluginsHolder().getPluginTypes(doSort = True)
433        for pluginType in pluginTypes:
434            if pluginType.isVisible() and pluginType.isActive():
435                self._tabs[pluginType.getId()] = self._tabCtrl.newTab(pluginType.getName(), pluginType.getName(),
436                                                                       urlHandlers.UHAdminPlugins.getURL( pluginType ))
437
438    def _setActiveSideMenuItem(self):
439        self._pluginsMenuItem.setActive()
440
441    def _setActiveTab(self):
442        if self._pluginTypeId is None:
443            self._tabs["Main"].setActive()
444        else:
445            self._tabs[self._pluginTypeId].setActive()
446
447
448    def _getPageContent(self, params):
449        if self._pluginTypeId is None:
450            html = WAdminPluginsMainTab().getHTML(params)
451        else:
452            html = WAdminPlugins(self._pluginTypeId, self._initialPlugin, self._user).getHTML( params )
453
454        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( html )
455
456class WAdminPlugins (wcomponents.WTemplated):
457
458    def __init__(self, pluginType, initialPlugin, user):
459        self._pluginType = pluginType
460        self._initialPlugin = initialPlugin
461        self._user = user
462
463    def getVars (self):
464        vars = wcomponents.WTemplated.getVars( self )
465
466        vars["PluginType"] = PluginsHolder().getPluginType(self._pluginType)
467        vars["InitialPlugin"] = self._initialPlugin
468        vars["Favorites"] = fossilize(self._user.getPersonalInfo().getBasket().getUsers().values(), IAvatarFossil)
469        vars["rbActive"] = info.HelperMaKaCInfo.getMaKaCInfoInstance().getRoomBookingModuleActive()
470        vars["baseURL"]=Config.getInstance().getBaseURL()
471
472        return vars
473
474class WAdminPluginsMainTab(wcomponents.WTemplated):
475
476    def getVars(self):
477        vars = wcomponents.WTemplated.getVars( self )
478
479        vars["PluginsHolder"] = PluginsHolder()
480
481        return vars
482
483class WPAdminPluginsActionResult(WPAdminPlugins):
484
485    def __init__(self, rh, pluginTypeId, initialPlugin, actionName, actionResult):
486        WPAdminPlugins.__init__(self, rh, pluginTypeId, initialPlugin)
487        self._actionName = actionName
488        self._actionResult = actionResult
489
490    def _getPageContent(self, params):
491        html = WAdminPluginsActionResult(self._pluginTypeId, self._initialPlugin, self._actionName, self._actionResult).getHTML(params)
492        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( html )
493
494class WAdminPluginsActionResult(wcomponents.WTemplated):
495
496    def __init__(self, pluginType, initialPlugin, actionName, actionResult):
497        self._pluginType = pluginType
498        self._initialPlugin = initialPlugin
499        self._actionName = actionName
500        self._actionResult = actionResult
501
502    def getVars(self):
503        variables = wcomponents.WTemplated.getVars( self )
504
505        variables["PluginType"] = PluginsHolder().getPluginType(self._pluginType)
506        variables["InitialPlugin"] = self._initialPlugin
507        variables["ActionName"] = self._actionName
508        variables["ActionResult"] = self._actionResult
509
510        return variables
511
512class WPServicesCommon( WPAdminsBase ):
513
514    def _setActiveSideMenuItem(self):
515        self._servicesMenuItem.setActive()
516
517    def _createTabCtrl( self ):
518        self._tabCtrl = wcomponents.TabControl()
519
520        self._subTabWebcast = self._tabCtrl.newTab( "webcast", _("Webcast"), \
521                urlHandlers.UHWebcast.getURL() )
522        self._subTabWebcast_Live = self._subTabWebcast.newSubTab( "live", _("Live"), \
523                urlHandlers.UHWebcast.getURL() )
524        self._subTabWebcast_Archive = self._subTabWebcast.newSubTab( "archive", _("Archive"), \
525                urlHandlers.UHWebcastArchive.getURL() )
526        self._subTabWebcast_Setup = self._subTabWebcast.newSubTab( "setup", _("Setup"), \
527                urlHandlers.UHWebcastSetup.getURL() )
528        self._subTabRecording = self._tabCtrl.newTab( "recording", _("Recording"), \
529                urlHandlers.UHRecording.getURL() )
530        self._subTabOAIPrivateConfig = self._tabCtrl.newTab( "oai-private", _("OAI Private Gateway"), \
531                urlHandlers.UHOAIPrivateConfig.getURL() )
532        self._subTabHTTPAPI = self._tabCtrl.newTab( "http_api", _("HTTP API"), \
533                urlHandlers.UHAdminAPIOptions.getURL() )
534        self._subTabHTTPAPI_Options = self._subTabHTTPAPI.newSubTab( "api_options", _("Options"), \
535                urlHandlers.UHAdminAPIOptions.getURL() )
536        self._subTabHTTPAPI_Keys = self._subTabHTTPAPI.newSubTab( "api_keys", _("API Keys"), \
537                urlHandlers.UHAdminAPIKeys.getURL() )
538
539    def _getPageContent(self, params):
540        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
541
542class WPRecording( WPServicesCommon ):
543
544    pageURL = "adminServices.py/recording"
545
546    def __init__(self, rh):
547        WPServicesCommon.__init__(self, rh)
548
549    def _getTabContent( self, params ):
550        return "under construction"
551        #wp = WRecording()
552        #return wp.getHTML(params)
553
554    def _setActiveTab( self ):
555        self._subTabRecording.setActive()
556
557class WPWebcast( WPServicesCommon ):
558
559    pageURL = "adminServices.py/webcast"
560
561    def __init__(self, rh):
562        WPServicesCommon.__init__(self, rh)
563
564    def _getTabContent( self, params ):
565        wp = WWebcast()
566        return wp.getHTML(params)
567
568    def _setActiveTab( self ):
569        self._subTabWebcast.setActive()
570
571
572class WWebcast( wcomponents.WTemplated ):
573
574    def getVars( self ):
575        vars = wcomponents.WTemplated.getVars( self )
576        wm = webcast.HelperWebcastManager.getWebcastManagerInstance()
577        channels = wm.getChannels()
578        iconremove = Config.getInstance().getSystemIconURL( "remove" )
579        iconarchive = Config.getInstance().getSystemIconURL( "archive" )
580        iconadd = Config.getInstance().getSystemIconURL( "add" )
581        list_onair = ""
582        for ch in channels:
583            name = ch.getName()
584            urlchannel = ch.getURL()
585            onair = ch.whatsOnAir()
586            isonair = ch.isOnAir()
587            color = "#edaaa8"
588            iconswitch = iconadd
589            urlswitch = urlHandlers.UHWebcastSwitchChannel.getURL()
590            urlswitch.addParam("chname",name)
591            form = ""
592            if isonair:
593                color = "#b7eda8"
594                iconswitch = iconremove
595            if onair:
596                try:
597                    title = onair.getTitle()
598                    id = onair.getId()
599                    if onair.getEvent():
600                        eventurl = urlHandlers.UHConferenceDisplay.getURL(onair.getEvent())
601                        title = """<a href="%s">%s</a>""" % (eventurl, title)
602                except:
603                    title = "Unrecognised event"
604                    id = ""
605                urlremovefromair = urlHandlers.UHWebcastRemoveFromAir.getURL()
606                urlremovefromair.addParam("chname",name)
607                form = """%s<a href="%s"><img src="%s" border="0"></a>""" % (title, urlremovefromair, iconremove)
608            list_onair += """<TR bgcolor="%s"><TD><a href="%s">%s</a></TD><TD>%s</TD><TD><a href="%s"><IMG SRC="%s" border="0"></A></TD></TR>""" % (color, urlchannel, name, form, urlswitch, iconswitch)
609        vars["onair"] = list_onair
610        list_webcasts = ""
611        webcasts = wm.getForthcomingWebcasts()
612        webcasts.sort(webcast.sortWebcastByDate)
613        urladdonair = urlHandlers.UHWebcastAddOnAir.getURL()
614        channeloptions = ""
615        for ch in wm.getChannels():
616            channeloptions += "<option>%s" % ch.getName()
617        for wc in webcasts:
618            if wc.getAudience(): # skip webcasts with an audience
619                continue
620            onair = wc in wm.whatsOnAir()
621            if not onair:
622                list_webcasts += """<form action="%s">""" % urladdonair
623            title = wc.getTitle()
624            if wc.getEvent():
625                eventurl = urlHandlers.UHConferenceDisplay.getURL(wc.getEvent())
626                title = """<a href="%s">%s</a>""" % (eventurl, title)
627            list_webcasts += "<TD>%s - %s</TD><TD>"% (wc.getStartDate().strftime("%Y-%m-%d %H:%M"),title)
628            if not onair:
629                urlarchivewebcast = urlHandlers.UHWebcastArchiveWebcast.getURL()
630                urlarchivewebcast.addParam("webcastid",wc.getId())
631                urlremovewebcast = urlHandlers.UHWebcastRemoveWebcast.getURL()
632                urlremovewebcast.addParam("webcastid",wc.getId())
633                list_webcasts += """<SELECT name="chname" onchange="this.form.submit();"><option>not on air%s</SELECT>""" % channeloptions
634                list_webcasts += """<input type="hidden" name="eventid" value="%s"></td><td><a href="%s"><img src="%s" border="0" alt="archive webcast"></a></td><td><a href="%s"><img src="%s" border="0" alt="delete webcast"></a>""" % (wc.getId(),urlarchivewebcast,iconarchive,urlremovewebcast,iconremove)
635            list_webcasts += "</TD></TR>"
636            if not onair:
637                list_webcasts += "</FORM>"
638        vars["addwebcastURL"] = urlHandlers.UHWebcastAddWebcast.getURL()
639        vars["webcasts"] = list_webcasts
640        return vars
641
642
643class WPWebcastArchive( WPServicesCommon ):
644
645    pageURL = "adminServices.py/webcastArchive"
646
647    def __init__(self, rh):
648        WPServicesCommon.__init__(self, rh)
649
650    def _getTabContent( self, params ):
651        wp = WWebcastArchive()
652        return wp.getHTML(params)
653
654    def _setActiveTab( self ):
655        self._subTabWebcast_Archive.setActive()
656
657
658class WWebcastArchive( wcomponents.WTemplated ):
659
660    def getVars( self ):
661        vars = wcomponents.WTemplated.getVars( self )
662        iconunarchive = Config.getInstance().getSystemIconURL( "unarchive" )
663        iconremove = Config.getInstance().getSystemIconURL( "remove" )
664        wm = webcast.HelperWebcastManager.getWebcastManagerInstance()
665        list_webcasts = ""
666        webcasts = wm.getArchivedWebcasts()
667        webcasts.sort(webcast.sortWebcastByDate)
668        for wc in webcasts:
669            if wc.getAudience(): # skip webcasts with an audience
670                continue
671            title = wc.getTitle()
672            if wc.getEvent():
673                eventurl = urlHandlers.UHConferenceDisplay.getURL(wc.getEvent())
674                title = """<a href="%s">%s</a>""" % (eventurl, title)
675            list_webcasts += "<TD>%s - %s</TD><TD>"% (wc.getStartDate().strftime("%Y-%m-%d %H:%M"),title)
676            urlunarchivewebcast = urlHandlers.UHWebcastUnArchiveWebcast.getURL()
677            urlunarchivewebcast.addParam("webcastid",wc.getId())
678
679            urlremovewebcast = urlHandlers.UHWebcastRemoveWebcast.getURL()
680            urlremovewebcast.addParam("webcastid",wc.getId())
681            list_webcasts += """<a href="%s"><img src="%s" border="0" alt="unarchive webcast"></a></td><td><a href="%s"><img src="%s" border="0" alt="delete webcast"></a>""" % (urlunarchivewebcast,iconunarchive,urlremovewebcast,iconremove)
682            list_webcasts += "</TD></TR>"
683        vars["webcasts"] = list_webcasts
684        return vars
685
686
687class WPWebcastSetup( WPServicesCommon ):
688
689    pageURL = "adminServices.py/webcastSetup"
690
691    def __init__(self, rh):
692        WPServicesCommon.__init__(self, rh)
693
694    def _getTabContent( self, params ):
695        wp = WWebcastSetup()
696        return wp.getHTML(params)
697
698    def _setActiveTab( self ):
699        self._subTabWebcast_Setup.setActive()
700
701
702class WWebcastSetup( wcomponents.WTemplated ):
703
704    def getVars( self ):
705        vars = wcomponents.WTemplated.getVars( self )
706        wm = webcast.HelperWebcastManager.getWebcastManagerInstance()
707        managers = wm.getManagers()
708        urlselectmanager = urlHandlers.UHWebcastSelectManager.getURL()
709        urlremovemanager = urlHandlers.UHWebcastRemoveManager.getURL()
710        vars["adminList"] = wcomponents.WPrincipalTable().getHTML( managers,  None, urlselectmanager, urlremovemanager, selectable=False )
711        channels = wm.getChannels()
712        iconremove = Config.getInstance().getSystemIconURL( "remove" )
713        iconadd = Config.getInstance().getSystemIconURL( "add" )
714        iconup = Config.getInstance().getSystemIconURL( "upArrow" )
715        icondown = Config.getInstance().getSystemIconURL( "downArrow" )
716        list_channels = """<table width="100%" cellspacing=0>"""
717        i = 0
718        for channel in channels:
719            i += 1
720            if int(i/2)*2 == i:
721                color = "#e5e5e5"
722            else:
723                color = "#eeeeee"
724            screenname = "%s (%sx%s)" % (channel.getName(),channel.getWidth(), channel.getHeight())
725            name = channel.getName()
726            churl = channel.getURL()
727            width = channel.getWidth()
728            height = channel.getHeight()
729            urlremove = urlHandlers.UHWebcastRemoveChannel.getURL()
730            urlremove.addParam("chname",name)
731            urlmoveup = urlHandlers.UHWebcastMoveChannelUp.getURL()
732            urlmoveup.addParam("chnb",i-1)
733            urlmovedown = urlHandlers.UHWebcastMoveChannelDown.getURL()
734            urlmovedown.addParam("chnb",i-1)
735            list_channels += """<tr bgcolor=%s><td valign=top><ul><li><a href="%s">%s</a><a href="%s"><img src="%s" border="0"></a><a href="%s"><img src="%s" border="0"></a><a href="%s"><img src="%s" border="0"></a></li>""" % (color,churl,screenname,urlremove,iconremove,urlmoveup,iconup,urlmovedown,icondown)
736            list_channels += "<ul><li>Streams:</li><ul>"
737            for stream in channel.getStreams():
738                url = stream.getURL()
739                format = stream.getFormat()
740                urlremovestream = urlHandlers.UHWebcastRemoveStream.getURL()
741                urlremovestream.addParam("chname",name)
742                urlremovestream.addParam("stformat",format)
743                list_channels += """<li><a href="%s">%s</a><a href="%s"><img src="%s" border="0"></a></li>""" % ( url, format, urlremovestream, iconremove )
744            urladdstream = urlHandlers.UHWebcastAddStream.getURL()
745            urladdstream.addParam("chname",name)
746            urlmodifychannel = urlHandlers.UHWebcastModifyChannel.getURL()
747            urlmodifychannel.addParam("chname",name)
748            list_channels += """<li>
749  <table bgcolor="#bbbbbb">
750    <form action="%s" method="POST">
751  <tr><td>format:</td><td><input name="stformat" size=5>
752  </td><td>url:</td><td><input name="sturl" size="20">
753  </td><td>
754  <input type="image" src="%s" name="submit" value="add stream" alt="add stream">
755  </td></tr>
756    </form>
757  </table></li></ul></ul></ul>
758    </td><td align=right>
759  <form action="%s" method="POST">
760  <table bgcolor="#bbbbbb">
761  <tr bgcolor="#999999"><td colspan=2><font color=white>Update Channel</font>
762  </td></tr><tr><td>
763  name:</td><td><input name="chnewname" value="%s" size=15>
764  </td></tr><tr><td>
765  url:</td><td><input name="churl" value="%s" size=30>
766  </td></tr><tr><td>
767  width:</td><td><input name="chwidth" value="%s" size=3>
768  </td></tr><tr><td>
769  height:</td><td><input name="chheight" value="%s" size=3>
770  </td></tr><tr><td colspan=2>
771  <input type="submit" name="submit" value="modify channel">
772  </td></tr>
773  </table>
774  </form>
775  </td></tr>""" % (urladdstream,iconadd,urlmodifychannel,name,churl,width,height)
776        list_channels += "</table>"
777        vars["channels"] = list_channels
778        vars["postURL"] = urlHandlers.UHWebcastAddChannel.getURL()
779
780        vars["saveWebcastSynchronizationURL"] = urlHandlers.UHWebcastSaveWebcastSynchronizationURL.getURL()
781        vars["webcastSynchronizationURL"] = wm.getWebcastSynchronizationURL()
782
783        vars["webcastManualSynchronize"] = urlHandlers.UHWebcastManualSynchronization.getURL()
784
785        return vars
786
787class WPWebcastSelectManager( WPWebcastSetup ):
788
789    def _getTabContent( self, params ):
790        wc = wcomponents.WUserSelection( urlHandlers.UHWebcastSelectManager.getURL(), forceWithoutExtAuth=True )
791        wc.setTitle("Select webcast administrator")
792        params["addURL"] =  urlHandlers.UHWebcastAddManager.getURL()
793        return wc.getHTML( params )
794
795
796class WPTemplatesCommon( WPAdminsBase ):
797
798    def _setActiveSideMenuItem(self):
799        self._templatesMenuItem.setActive()
800
801    def _createTabCtrl( self ):
802        self._tabCtrl = wcomponents.TabControl()
803
804        self._subTabBadges = self._tabCtrl.newTab( "badges", _("Badges"), \
805                urlHandlers.UHBadgeTemplates.getURL() )
806        self._subTabPosters = self._tabCtrl.newTab( "posters", _("Posters"), \
807                urlHandlers.UHPosterTemplates.getURL() )
808        self._subTabStyles = self._tabCtrl.newTab( "styles", _("Timetable Styles"), \
809                urlHandlers.UHAdminsStyles.getURL() )
810        self._subTabCSSTpls = self._tabCtrl.newTab( "styles", _("Conference Styles"), \
811                urlHandlers.UHAdminsConferenceStyles.getURL() )
812
813    def _getPageContent(self, params):
814        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
815        if self._showAdmin:
816            return WPAdminsBase._getBody( self, params )
817        else:
818            return self._getTabContent( params )
819
820class WPAdminsConferenceStyles( WPTemplatesCommon ):
821
822    def _getTabContent( self, params ):
823        wp = WAdminsConferenceStyles()
824        return wp.getHTML(params)
825
826    def _setActiveTab( self ):
827        self._subTabCSSTpls.setActive()
828
829class WAdminsConferenceStyles(wcomponents.WTemplated):
830
831    def getVars( self ):
832        vars = wcomponents.WTemplated.getVars( self )
833        vars["contextHelpText"] = _("This is the list of templates that an organizer can use to customize a conference")
834        cssTplsModule=ModuleHolder().getById("cssTpls")
835        vars["cssTplsModule"] = cssTplsModule
836        return vars
837
838
839class WPAdminsStyles( WPTemplatesCommon ):
840
841    def _getTabContent( self, params ):
842        wp = WAdminsStyles()
843        return wp.getHTML(params)
844
845    def _setActiveTab( self ):
846        self._subTabStyles.setActive()
847
848class WAdminsStyles(wcomponents.WTemplated):
849
850    def getVars( self ):
851        vars = wcomponents.WTemplated.getVars( self )
852        styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
853        vars["styleMgr"] = styleMgr
854        baseTPLPath = styleMgr.getBaseTPLPath()
855        baseCSSPath = styleMgr.getBaseCSSPath()
856        vars["contextHelpText"] = i18nformat("""- <b>_("TPL files")</b> _("are mandatory and located in"):<br/>%s<br/>- <b>_("CSS files")</b> _("are optional and located in"):<br/>%s<br/>- <b>_("Lines in red")</b> _("indicate missing .tpl or .css files (these styles will not be presented to the users"))""") % (baseTPLPath,baseCSSPath)
857        vars["deleteIconURL"] = Config.getInstance().getSystemIconURL("remove")
858        return vars
859
860class WPAdminsAddStyle( WPAdminsStyles ):
861
862    def _getTabContent( self, params ):
863        wp = WAdminsAddStyle()
864        return wp.getHTML(params)
865
866class WAdminsAddStyle(wcomponents.WTemplated):
867
868    def _getAllFiles(self, basePath, extension, excludedDirs=[]):
869        collectedFiles = []
870        for root, dirs, files in os.walk(basePath):
871            for excluded in excludedDirs:
872                if excluded in dirs:
873                    dirs.remove(excluded)
874            for filename in files:
875                fullPath = os.path.join(root, filename)
876                if os.path.isfile(fullPath) and filename.endswith(extension):
877                    collectedFiles.append(os.path.relpath(fullPath, basePath))
878        return sorted(collectedFiles)
879
880    def getVars( self ):
881        vars = wcomponents.WTemplated.getVars( self )
882        styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
883        vars["styleMgr"] = styleMgr
884        baseTPLPath = styleMgr.getBaseTPLPath()
885        baseCSSPath = styleMgr.getBaseCSSPath()
886        baseXSLPath = styleMgr.getBaseXSLPath()
887        vars["availableTemplates"] = self._getAllFiles(baseTPLPath, '.tpl', excludedDirs=['include'])
888        vars["availableStyleSheets"] = self._getAllFiles(baseXSLPath, '.xsl', excludedDirs=['include'])
889        vars["availableCSS"] = self._getAllFiles(baseCSSPath, '.css')
890        vars["xslContextHelpText"] = r"Lists all XSL files in %s (except special folders named \'include\', which are reserved)" % baseXSLPath
891        vars["tplContextHelpText"] = r"Lists all TPL files in %s (except special folders named \'include\', which are reserved)" % baseTPLPath
892        vars["cssContextHelpText"] = "Lists all CSS files in %s" % baseCSSPath
893        return vars
894
895class WAdminTemplates(wcomponents.WTemplated):
896
897    def getVars( self ):
898        vars = wcomponents.WTemplated.getVars( self )
899        return vars
900
901class WPBadgeTemplates( WPTemplatesCommon ):
902    pageURL = "badgeTemplates.py"
903
904    def __init__(self, rh):
905        WPTemplatesCommon.__init__(self, rh)
906
907    def _getTabContent( self, params ):
908        wp = WBadgeTemplates(conference.CategoryManager().getDefaultConference())
909        return wp.getHTML(params)
910
911    def _setActiveTab( self ):
912        self._subTabBadges.setActive()
913
914class WPPosterTemplates( WPTemplatesCommon ):
915    pageURL = "posterTemplates.py"
916
917    def __init__(self, rh):
918        WPTemplatesCommon.__init__(self, rh)
919
920    def _getTabContent( self, params ):
921        wp = WPosterTemplates(conference.CategoryManager().getDefaultConference())
922        return wp.getHTML(params)
923
924    def _setActiveTab( self ):
925        self._subTabPosters.setActive()
926
927class WPBadgeTemplateDesign( WPTemplatesCommon ):
928
929    def __init__(self, rh, conf, templateId = None, new = False):
930        WPTemplatesCommon.__init__(self, rh)
931        self._conf = conf
932        self.__templateId = templateId
933        self.__new = new
934
935    def _setActiveTab( self ):
936        self._subTabBadges.setActive()
937
938    def _getTabContent( self, params ):
939        wc = conferences.WConfModifBadgeDesign( self._conf, self.__templateId, self.__new )
940        return wc.getHTML()
941
942class WPPosterTemplateDesign( WPTemplatesCommon ):
943
944    def __init__(self, rh, conf, templateId = None, new = False):
945        WPTemplatesCommon.__init__(self, rh)
946        self._conf = conf
947        self.__templateId = templateId
948        self.__new = new
949
950    def _setActiveTab( self ):
951        self._subTabPosters.setActive()
952
953    def _getTabContent( self, params ):
954        wc = conferences.WConfModifPosterDesign( self._conf, self.__templateId, self.__new )
955        return wc.getHTML()
956
957class WBadgeTemplates( wcomponents.WTemplated ):
958
959    def __init__( self, conference, user=None ):
960        self.__conf = conference
961        self._user=user
962
963    def getVars( self ):
964
965        dconf = self.__conf
966
967        vars = wcomponents.WTemplated.getVars( self )
968        vars["NewDefaultTemplateURL"] = str(urlHandlers.UHModifDefTemplateBadge.getURL(dconf,
969                                                                             dconf.getBadgeTemplateManager().getNewTemplateId(), new = True))
970
971        templateListHTML = []
972        first = True
973
974
975        sortedTemplates = dconf.getBadgeTemplateManager().getTemplates().items()
976        sortedTemplates.sort(lambda item1, item2: cmp(item1[1].getName(), item2[1].getName()))
977        for templateId, template in sortedTemplates:
978            templateListHTML.append("""              <tr>""")
979            templateListHTML.append("""                <td>""")
980
981            radio = []
982            radio.append("""                  <input type="radio" name="templateId" value='""")
983            radio.append(str(templateId))
984            radio.append("""' id='""")
985            radio.append(str(templateId))
986            radio.append("""'""")
987            if first:
988                first = False
989                radio.append( _(""" CHECKED """))
990            radio.append(""">""")
991            templateListHTML.append("".join(radio))
992            templateListHTML.append("".join (["""                  """,
993                                              """<label for='""",
994                                              str(templateId),
995                                              """'>""",
996                                              template.getName(),
997                                              """</label>""",
998                                              """&nbsp;&nbsp;&nbsp;"""]))
999
1000            edit = []
1001            edit.append("""                  <a href='""")
1002            edit.append(str(urlHandlers.UHConfModifBadgeDesign.getURL(dconf, templateId)))
1003            edit.append("""'><img src='""")
1004            edit.append(str(Config.getInstance().getSystemIconURL("file_edit")))
1005            edit.append("""' border='0'></a>&nbsp;""")
1006            templateListHTML.append("".join(edit))
1007
1008            delete = []
1009            delete.append("""                  <a href='""")
1010            delete.append(str(urlHandlers.UHConfModifBadgePrinting.getURL(dconf, deleteTemplateId=templateId)))
1011            delete.append("""'><img src='""")
1012            delete.append(str(Config.getInstance().getSystemIconURL("smallDelete")))
1013            delete.append("""' border='0'></a>&nbsp;""")
1014            templateListHTML.append("".join(delete))
1015
1016            templateListHTML.append("""                </td>""")
1017            templateListHTML.append("""              </tr>""")
1018
1019        vars["templateList"] = "\n".join(templateListHTML)
1020
1021        vars['PDFOptions'] = WConfModifBadgePDFOptions(dconf, showKeepValues = False, showTip = False).getHTML()
1022
1023        return vars
1024
1025class WPosterTemplates( wcomponents.WTemplated ):
1026
1027    def __init__( self, conference, user=None ):
1028        self.__conf = conference
1029        self._user=user
1030
1031    def getVars( self ):
1032
1033        dconf = self.__conf
1034
1035        vars = wcomponents.WTemplated.getVars( self )
1036        vars["NewDefaultTemplateURL"] = str(urlHandlers.UHModifDefTemplatePoster.getURL(dconf,
1037                                                                             dconf.getPosterTemplateManager().getNewTemplateId(), new = True))
1038
1039        templateListHTML = []
1040        first = True
1041
1042
1043        sortedTemplates = dconf.getPosterTemplateManager().getTemplates().items()
1044        sortedTemplates.sort(lambda item1, item2: cmp(item1[1].getName(), item2[1].getName()))
1045        for templateId, template in sortedTemplates:
1046            templateListHTML.append("""              <tr>""")
1047            templateListHTML.append("""                <td>""")
1048
1049            radio = []
1050            radio.append("""                  <input type="radio" name="templateId" value='""")
1051            radio.append(str(templateId))
1052            radio.append("""' id='""")
1053            radio.append(str(templateId))
1054            radio.append("""'""")
1055            if first:
1056                first = False
1057                radio.append( _(""" CHECKED """))
1058            radio.append(""">""")
1059            templateListHTML.append("".join(radio))
1060            templateListHTML.append("".join (["""                  """,
1061                                              """<label for='""",
1062                                              str(templateId),
1063                                              """'>""",
1064                                              template.getName(),
1065                                              """</label>""",
1066                                              """&nbsp;&nbsp;&nbsp;"""]))
1067
1068            edit = []
1069            edit.append("""                  <a href='""")
1070            edit.append(str(urlHandlers.UHConfModifPosterDesign.getURL(dconf, templateId)))
1071            edit.append("""'><img src='""")
1072            edit.append(str(Config.getInstance().getSystemIconURL("file_edit")))
1073            edit.append("""' border='0'></a>&nbsp;""")
1074            templateListHTML.append("".join(edit))
1075
1076            delete = []
1077            delete.append("""                  <a href='""")
1078            delete.append(str(urlHandlers.UHConfModifPosterPrinting.getURL(dconf, deleteTemplateId=templateId)))
1079            delete.append("""'><img src='""")
1080            delete.append(str(Config.getInstance().getSystemIconURL("smallDelete")))
1081            delete.append("""' border='0'></a>&nbsp;""")
1082            clone = []
1083            clone.append("""                  <a href='""")
1084            clone.append(str(urlHandlers.UHConfModifPosterPrinting.getURL(dconf, copyTemplateId=templateId)))
1085            clone.append("""'><img src='""")
1086            clone.append(str(Config.getInstance().getSystemIconURL("smallCopy")))
1087            clone.append("""' border='0'></a>&nbsp;""")
1088            templateListHTML.append("".join(delete))
1089            templateListHTML.append("".join(clone))
1090
1091            templateListHTML.append("""                </td>""")
1092            templateListHTML.append("""              </tr>""")
1093
1094        vars["templateList"] = "\n".join(templateListHTML)
1095
1096        return vars
1097
1098
1099class WPUsersAndGroupsCommon(WPAdminsBase):
1100
1101    def _setActiveSideMenuItem(self):
1102        self._usersAndGroupsMenuItem.setActive()
1103
1104    def _createTabCtrl( self ):
1105        self._tabCtrl = wcomponents.TabControl()
1106
1107        self._subTabMain = self._tabCtrl.newTab( "main", _("Main"), \
1108                urlHandlers.UHUserManagement.getURL() )
1109        self._subTabUsers = self._tabCtrl.newTab( "users", _("Manage Users"), \
1110                urlHandlers.UHUsers.getURL() )
1111        self._subTabGroups = self._tabCtrl.newTab( "groups", _("Manage Groups"), \
1112                urlHandlers.UHGroups.getURL() )
1113
1114    def _getPageContent(self, params):
1115
1116        #if self._showAdmin:
1117        #    html = WPAdminsBase._getBody( self, params )
1118        #else:
1119        #    html = wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
1120
1121        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
1122
1123    #def _getBody(self, params):
1124    #    if self._showAdmin:
1125    #        return WPAdminsBase._getBody( self, params )
1126    #    else:
1127    #        return self._getTabContent( params )
1128
1129class WUserManagement( wcomponents.WTemplated ):
1130
1131    def getVars( self ):
1132        vars = wcomponents.WTemplated.getVars( self )
1133        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1134        iconDisabled = str(Config.getInstance().getSystemIconURL( "disabledSection" ))
1135        iconEnabled = str(Config.getInstance().getSystemIconURL( "enabledSection" ))
1136        vars["accountCreationData"] = ""
1137        url = urlHandlers.UHUserManagementSwitchAuthorisedAccountCreation.getURL()
1138        if minfo.getAuthorisedAccountCreation():
1139            icon = iconEnabled
1140        else:
1141            icon = iconDisabled
1142        vars["accountCreationData"] += i18nformat("""<a href="%s"><img src="%s" border="0"> _("Public Account Creation")</a>""") % (str(url), icon)
1143        url = urlHandlers.UHUserManagementSwitchNotifyAccountCreation.getURL()
1144        if minfo.getNotifyAccountCreation():
1145            icon = iconEnabled
1146        else:
1147            icon = iconDisabled
1148        vars["accountCreationData"] += i18nformat("""<br><a href="%s"><img src="%s" border="0"> _("Notify Account Creation by Email")</a>""") % (str(url), icon)
1149        url = urlHandlers.UHUserManagementSwitchModerateAccountCreation.getURL()
1150        if minfo.getModerateAccountCreation():
1151            icon = iconEnabled
1152        else:
1153            icon = iconDisabled
1154        vars["accountCreationData"] += i18nformat("""<br><a href="%s"><img src="%s" border="0"> _("Moderate Account Creation")</a>""") % (str(url), icon)
1155        vars["moderators"] = ""
1156        vars["moderatorsURL"] = ""
1157        return vars
1158
1159
1160class WPUserManagement( WPUsersAndGroupsCommon ):
1161    pageURL = "userManagement.py"
1162
1163    def __init__(self, rh, params):
1164        WPUsersAndGroupsCommon.__init__(self, rh)
1165        self._params = params
1166
1167    def _getTabContent( self, params ):
1168        wp = WUserManagement()
1169        return wp.getHTML(self._params)
1170
1171    def _setActiveTab( self ):
1172        self._subTabMain.setActive()
1173
1174class WPUserCommon( WPUsersAndGroupsCommon ):
1175
1176    def _setActiveTab( self ):
1177        self._subTabUsers.setActive()
1178
1179class WBrowseUsers( wcomponents.WTemplated ):
1180
1181    def __init__( self, letter=None, browseIndex="surName" ):
1182        self._letter = letter
1183        self._browseIndex = browseIndex
1184
1185    def getVars( self ):
1186        vars = wcomponents.WTemplated.getVars( self )
1187        nameIndex = indexes.IndexesHolder().getById(self._browseIndex)
1188        letters = nameIndex.getBrowseIndex()
1189        vars["browseIndex"] = """
1190        <span class="nav_border"><a class="nav_link" href='' onClick="document.browseForm.letter.value='clear';document.browseForm.submit();return false;">clear</a></span>"""
1191        if self._letter == "all":
1192            vars["browseIndex"] += """
1193        [all] """
1194        else:
1195            vars["browseIndex"] += """
1196        <span class="nav_border"><a class="nav_link" href='' onClick="document.browseForm.letter.value='all';document.browseForm.submit();return false;">all</a></span> """
1197        for letter in letters:
1198            if self._letter == letter:
1199                vars["browseIndex"] += """\n[%s] """ % letter
1200            else:
1201                vars["browseIndex"] += """\n<span class="nav_border"><a class="nav_link" href='' onClick="document.browseForm.letter.value='%s';document.browseForm.submit();return false;">%s</a></span> """ % (escape(letter,True),letter)
1202        vars["browseResult"] = ""
1203        if self._letter != None:
1204            ah = user.AvatarHolder()
1205            if self._letter != "all":
1206                res = ah.matchFirstLetter(self._browseIndex, self._letter, onlyActivated=False, forceWithoutExtAuth=False)
1207            else:
1208                res = ah.getValuesToList()
1209            if self._browseIndex == "surName" or self._browseIndex == "status":
1210                res.sort(utils.sortUsersByName)
1211            elif self._browseIndex == "name":
1212                res.sort(utils.sortUsersByFirstName)
1213            elif self._browseIndex == "organisation":
1214                res.sort(utils.sortUsersByAffiliation)
1215            elif self._browseIndex == "email":
1216                res.sort(utils.sortUsersByEmail)
1217            else:
1218                res.sort()
1219            vars["browseResult"] = WHTMLUserList(res).getHTML(vars)
1220        return vars
1221
1222class WHTMLUserList(wcomponents.WTemplated):
1223
1224    def __init__(self, userList):
1225        self._userList = userList
1226
1227    def getVars( self ):
1228        vars = wcomponents.WTemplated.getVars( self )
1229        color="white"
1230        ul = []
1231        vars["userList"] = ""
1232        ul.append( i18nformat("""
1233                        <tr>
1234                            <td bgcolor="white" style="color:black" align="center"><b>%s  _("users")</b></td>
1235                        </tr>
1236                        """)%len(self._userList))
1237        for u in self._userList:
1238            if color=="white":
1239                color="#ececec"
1240            else:
1241                color="white"
1242            organisation = ""
1243            if u.getOrganisation() != "":
1244                organisation = " (%s)" % u.getOrganisation()
1245            email = ""
1246            if u.getEmail() != "":
1247                email = " (%s)" % u.getEmail()
1248            url = vars["userDetailsURLGen"]( u )
1249            name = u.getFullName()
1250            if name == "":
1251                name = "no name"
1252            ul.append("""<tr>
1253                            <td bgcolor="%s"><a href="%s">%s</a> %s %s</td>
1254                         </tr>"""%(color, url, self.htmlText(name) , self.htmlText(email),self.htmlText(organisation)) )
1255        if ul:
1256            vars["userList"] += "".join( ul )
1257        else:
1258            vars["userList"] += i18nformat("""<tr>
1259                            <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp; _("No users returned")</span></td></tr>""")
1260        return vars
1261
1262class WUserList(wcomponents.WTemplated):
1263
1264    def __init__( self, criteria, onlyActivated=True ):
1265        self._criteria = criteria
1266        self._onlyActivated=onlyActivated
1267
1268    def _performSearch( self, criteria ):
1269        ah = user.AvatarHolder()
1270        if  criteria["surName"] == "*" or \
1271            criteria["name"] =="*" or \
1272            criteria["email"] =="*" or \
1273            criteria["organisation"] =="*":
1274            res=ah.getValuesToList()
1275        else:
1276            res = ah.match(criteria, onlyActivated=self._onlyActivated, forceWithoutExtAuth=True)
1277        res.sort(utils.sortUsersByName)
1278        return res
1279
1280    def getVars( self ):
1281        vars = wcomponents.WTemplated.getVars( self )
1282        vars["nbUsers"] = indexes.IndexesHolder().getById("email").getLength()
1283        vars["createUserURL"] = urlHandlers.UHUserCreation.getURL()
1284        vars["mergeUsersURL"] = urlHandlers.UHUserMerge.getURL()
1285        vars["logMeAsURL"] = urlHandlers.UHLogMeAs.getURL()
1286        vars["searchUsersURL"] = urlHandlers.UHUsers.getURL()
1287        vars["browseUsersURL"] = urlHandlers.UHUsers.getURL()
1288        vars["browseOptions"] = ""
1289        options = { "surName": _("by last name"),
1290                    "name": _("by first name"),
1291                    "organisation": _("by affiliation"),
1292                    "email": _("by email address"),
1293                    "status": _("by status") }
1294        for key in options.keys():
1295            if key == vars.get("browseIndex","surName"):
1296                vars["browseOptions"] += """<option value="%s" selected> %s""" % (key, options[key])
1297            else:
1298                vars["browseOptions"] += """<option value="%s"> %s""" % (key, options[key])
1299        vars["browseUsers"] = WBrowseUsers(vars.get("letter",None),vars.get("browseIndex","surName")).getHTML(vars)
1300        vars["users"] = ""
1301        if self._criteria:
1302            userList = self._performSearch(self._criteria)
1303            vars["users"] = WHTMLUserList(userList).getHTML(vars)
1304        return vars
1305
1306
1307class WPUserList(WPUserCommon):
1308    pageURL = "userList.py"
1309
1310    def __init__(self, rh, params):
1311        WPUserCommon.__init__(self, rh)
1312        self._params = params
1313
1314    def _getTabContent( self, params ):
1315        criteria = {}
1316        if filter(lambda x: self._params[x], self._params):
1317            criteria["surName"] = self._params.get("sSurName","")
1318            criteria["name"] = self._params.get("sName","")
1319            criteria["email"] = self._params.get("sEmail","")
1320            criteria["organisation"] = self._params.get("sOrganisation","")
1321        comp = WUserList(criteria, onlyActivated=False)
1322        self._params["userDetailsURLGen"] = urlHandlers.UHUserDetails.getURL
1323        return comp.getHTML(self._params)
1324
1325
1326class WPUserCreation(WPUserCommon):
1327
1328    def __init__(self, rh, params, participation=None):
1329        WPUserCommon.__init__(self, rh)
1330        self._params = params
1331        self._participation=participation
1332
1333    def _getTabContent(self, params ):
1334        pars = self._params
1335        p = wcomponents.WUserRegistration()
1336        pars["defaultLang"] = pars.get("lang", "")
1337        pars["defaultTZ"] = pars.get("timezone", "")
1338        pars["defaultTZMode"] = pars.get("displayTZMode", "")
1339        pars["postURL"] =  urlHandlers.UHUserCreation.getURL()
1340        if pars["msg"] != "":
1341            pars["msg"] = "<table bgcolor=\"gray\"><tr><td bgcolor=\"white\">\n<font size=\"+1\" color=\"red\"><b>%s</b></font>\n</td></tr></table>"%pars["msg"]
1342        if self._participation is not None:
1343            pars["email"]=self._participation.getEmail()
1344            pars["name"]=self._participation.getFirstName()
1345            pars["surName"]=self._participation.getFamilyName()
1346            pars["title"]=self._participation.getTitle()
1347            pars["organisation"]=self._participation.getAffiliation()
1348            pars["address"]=self._participation.getAddress()
1349            pars["telephone"]=self._participation.getPhone()
1350            pars["fax"]=self._participation.getFax()
1351        return p.getHTML( pars )
1352
1353class WPUserCreationNonAdmin(WPUserCreation):
1354
1355    def _getNavigationDrawer(self):
1356        pass
1357
1358    def _getBody(self, params):
1359        return WPUserCreation._getTabContent(self, params)
1360
1361class WPUserCreated( WPUserCommon ):
1362
1363    def __init__(self, rh, av):
1364        WPUserCommon.__init__(self, rh)
1365        self._av = av
1366
1367    def _getTabContent(self, params ):
1368        p = wcomponents.WUserCreated(self._av)
1369        pars = {"signInURL" : urlHandlers.UHSignIn.getURL()}
1370        return p.getHTML( pars )
1371
1372class WPUserCreatedNonAdmin(WPUserCreated):
1373
1374    def _getNavigationDrawer(self):
1375        pass
1376
1377    def _getBody(self, params):
1378        return WPUserCreated._getTabContent(self, params)
1379
1380
1381class WPUserExistWithIdentity( WPUserCommon ):
1382
1383    def __init__(self, rh, av):
1384        WPUserCommon.__init__(self, rh)
1385        self._av = av
1386
1387    def _getTabContent(self, params ):
1388        p = wcomponents.WUserSendIdentity(self._av)
1389        pars = {"postURL" : urlHandlers.UHSendLogin.getURL(self._av)}
1390        return p.getHTML( pars )
1391
1392class WPUserExistWithIdentityNonAdmin(WPUserExistWithIdentity):
1393
1394    def _getNavigationDrawer(self):
1395        pass
1396
1397    def _getBody(self, params):
1398        return WPUserExistWithIdentity._getTabContent(self, params)
1399
1400
1401class WPUserBase(WPUserCommon):
1402
1403    def __init__( self, rh, av=None ):
1404        WPUserCommon.__init__( self, rh )
1405        self._avatar = av
1406
1407
1408class WUserIdentitiesTable(wcomponents.WTemplated):
1409
1410    def __init__( self, av ):
1411        self._avatar = av
1412
1413    def getVars( self ):
1414        vars = wcomponents.WTemplated.getVars( self )
1415        il = []
1416        am = AuthenticatorMgr()
1417        authTagList = [i.getId() for i in am.getList()]
1418
1419        vars["identityItems"] = filter(lambda x: not x.getAuthenticatorTag() in authTagList, self._avatar.getIdentityList())
1420        vars["avatar"] = self._avatar
1421        vars["locator"] = self._avatar.getLocator().getWebForm()
1422        vars["accountManagementActive"] = 'Local' in authTagList
1423        return vars
1424
1425
1426class WUserBaskets(wcomponents.WTemplated):
1427
1428    def __init__(self, av):
1429        self._avatar = av
1430
1431    def getHTML( self, params ):
1432        params['user'] = self._avatar;
1433        return wcomponents.WTemplated.getHTML( self, params )
1434
1435
1436class WUserPreferences(wcomponents.WTemplated):
1437
1438    def __init__(self, av):
1439        self._avatar = av
1440
1441    def getVars(self):
1442        vars = wcomponents.WTemplated.getVars( self )
1443        vars["showPastEvents"] = self._avatar.getPersonalInfo().getShowPastEvents()
1444        return vars
1445
1446class WUserDetails(wcomponents.WTemplated):
1447
1448    def __init__(self, av):
1449        self._avatar = av
1450
1451    def getHTML( self, currentUser, params ):
1452        self._currentUser = currentUser
1453        return wcomponents.WTemplated.getHTML( self, params )
1454
1455    def getVars(self):
1456        vars = wcomponents.WTemplated.getVars( self )
1457        u = self._avatar
1458        vars["userId"] = u.getId()
1459        vars["surName"] = self.htmlText(u.getSurName())
1460        vars["name"] = self.htmlText(u.getName())
1461        vars["organisation"] = self.htmlText(u.getOrganisations()[0])
1462        titleDic = {}
1463        for title in TitlesRegistry().getList():
1464            titleDic[title] = title
1465        vars["titleList"] = titleDic
1466        vars["title"] = self.htmlText(u.getTitle())
1467        vars["address"] = self.htmlText(u.getAddresses()[0])
1468        vars["email"] = self.getEmailsHTML(u)
1469        vars["onlyEmail"] = self.htmlText(u.getEmail())
1470        vars["secEmails"] = ", ".join(u.getSecondaryEmails())
1471        vars["lang"] = self.htmlText(u.getLang())
1472        vars["telephon"] = self.htmlText(u.getTelephones()[0])
1473        vars["fax"] = self.htmlText(u.getFaxes()[0])
1474        vars["locator"] = self.htmlText(self._avatar.getLocator().getWebForm())
1475        vars["identities"] = ""
1476        vars["status"] = self._avatar.getStatus()
1477        vars["unlockedFields"] = self._avatar.getNotSyncedFields()
1478        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1479        al = minfo.getAdminList()
1480        if self._currentUser == self._avatar or \
1481              self._currentUser in al.getList() or \
1482              len(self._avatar.getIdentityList())==0:
1483            vars["identities"] = WUserIdentitiesTable( self._avatar ).getHTML( { "addIdentityURL": vars["addIdentityURL"], "removeIdentityURL": vars["removeIdentityURL"] })
1484        vars["activeButton"] = ""
1485        if self._currentUser in al.getList() and not self._avatar.isActivated():
1486            vars["activeButton"] = i18nformat("""<form action="%s" method="POST"><td bgcolor="white" width="100%%"\
1487                    valign="top" align="left">&nbsp;&nbsp;&nbsp;<input type="submit" class="btn" \
1488                    value=" _("activate the account") "></td></form>""")%vars["activeURL"]
1489        vars["categoryManager"] = ""
1490        categs = u.getLinkTo("category","manager")
1491        for categ in categs:
1492            target = CategoryWebLocator({"categId": categ.getId()}).getObject()
1493            if target == None:
1494                u.unlinkTo(categ,"manager")
1495            else:
1496                vars["categoryManager"] += """<a href="%s">%s</a><br>""" % (urlHandlers.UHCategoryDisplay.getURL(categ), categ.getTitle())
1497
1498        vars["eventManager"] = ""
1499        ch = ConferenceHolder()
1500        events = u.getLinkTo("conference","manager")
1501        for event in events:
1502            try:
1503                ch.getById(event.getId())
1504                vars["eventManager"] += """<a href="%s">%s</a><br>""" % (urlHandlers.UHConferenceDisplay.getURL(event), event.getTitle())
1505            except MaKaCError, e:
1506                u.unlinkTo(event,"manager")
1507
1508        return vars
1509
1510    def getEmailsHTML(self, u):
1511        html = [self.htmlText(u.getEmails()[0])]
1512        if u.getSecondaryEmails():
1513            html.append(""" <font color="grey"><small>(""")
1514            html.append(", ".join(u.getSecondaryEmails()))
1515            html.append(")</small></font>")
1516        return "".join(html)
1517
1518class WPPersonalArea(WPUserBase):
1519
1520    def _getBody( self, params ):
1521        self._createTabCtrl()
1522        self._setActiveTab()
1523        html = wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
1524        frame = personalization.WPersAreaFrame()
1525        p = { "body": html,
1526              "userName": self._avatar.getStraightFullName() }
1527        return frame.getHTML( p )
1528
1529    def _createTabCtrl( self ):
1530        self._tabCtrl = wcomponents.TabControl()
1531        self._tabDetails = self._tabCtrl.newTab( "details", _("Account Details"), \
1532                urlHandlers.UHUserDetails.getURL(self._avatar) )
1533
1534        """
1535            This tab is not needed any more. Currently only has information about
1536            showing or hiding advacned tabs. These advanced tabs has been turned into
1537            a side menu. Maybe the tab is needed in the future.
1538        """
1539        self._tabPreferences = self._tabCtrl.newTab( "preferences", _("Preferences"), \
1540                urlHandlers.UHUserPreferences.getURL() )
1541
1542        self._tabBaskets = self._tabCtrl.newTab( "baskets", _("Favorites"), \
1543                urlHandlers.UHUserBaskets.getURL() )
1544
1545        self._tabAPI = self._tabCtrl.newTab( "api", _("HTTP API"), \
1546                urlHandlers.UHUserAPI.getURL(self._avatar) )
1547
1548    def _getNavigationDrawer(self):
1549        return wcomponents.WSimpleNavigationDrawer(_("User Details"))
1550
1551
1552class WPUserDetails( WPPersonalArea ):
1553
1554    def _getTabContent( self, params ):
1555        c = WUserDetails( self._avatar )
1556        params["modifyUserURL"] = urlHandlers.UHUserModification.getURL( self._avatar )
1557        params["addIdentityURL"] = urlHandlers.UHUserIdentityCreation.getURL( self._avatar )
1558        params["removeIdentityURL"] = urlHandlers.UHUserRemoveIdentity.getURL( self._avatar )
1559        params["activeURL"] = urlHandlers.UHUserActive.getURL( self._avatar )
1560        return c.getHTML( self._getAW().getUser(), params )
1561
1562    def _setActiveTab( self ):
1563        self._tabDetails.setActive()
1564
1565
1566class WPUserBaskets( WPPersonalArea ):
1567
1568    def _getTabContent( self, params ):
1569        c = WUserBaskets( self._avatar )
1570
1571        return c.getHTML( params )
1572
1573    def _setActiveTab( self ):
1574        self._tabBaskets.setActive()
1575
1576
1577class WPUserPreferences( WPPersonalArea ):
1578
1579    def _getTabContent( self, params ):
1580        c = WUserPreferences( self._avatar )
1581        return c.getHTML( params )
1582
1583    def _setActiveTab( self ):
1584        self._tabPreferences.setActive()
1585
1586### This class is not used anymore. To remove
1587class WUserModify(wcomponents.WTemplated):
1588
1589    def __init__( self, avatar ):
1590        self._avatar = avatar
1591
1592    def getVars( self ):
1593        vars = wcomponents.WTemplated.getVars( self )
1594        u = self._avatar
1595        t = vars.get("title", u.getTitle())
1596        vars["titles"] = TitlesRegistry().getSelectItemsHTML(t)
1597        vars["locator"] = u.getLocator().getWebForm()
1598        vars["Wtitle"] = _("Modifying an existing user")
1599        vars["name"] = vars.get("name", u.getName())
1600        vars["surName"] =  vars.get("surName", u.getSurName())
1601        vars["title"] = vars.get("title", u.getTitle())
1602        vars["organisation"] = vars.get("organisation", u.getOrganisations()[0])
1603        vars["address"] = vars.get("address", u.getAddresses()[0])
1604        vars["email"] = vars.get("email", u.getEmails()[0])
1605        vars["secEmails"] = self._getSecEmailHTML(vars.get("secEmails", u.getSecondaryEmails()))
1606        vars["telephone"] = vars.get("telephone", u.getTelephones()[0])
1607        vars["fax"] =  vars.get("fax", u.getFaxes()[0])
1608
1609        return vars
1610
1611    def _getSecEmailHTML(self, secEmails):
1612        html = [ i18nformat("""<input type="text" name="secEmailAdd" value="" size="25"><input type="submit" name="addSecEmail" value="_("Add")"><br>""")]
1613        emails = []
1614        for email in secEmails:
1615            emails.append("""<input type="hidden" name="secEmails" value="%s">
1616                            <input type="checkbox" name="secEmailRemove" value="%s"> %s"""%(email, email, email))
1617        html.append("<br>".join(emails))
1618        if secEmails:
1619            html.append( i18nformat("""<input type="submit" name="removeSecEmail" value="_("Remove")">"""))
1620
1621        return "\n".join(html)
1622
1623### This class is not used anymore. To remove
1624class WPUserModification( WPUserDetails ):
1625
1626    def __init__(self, rh, avatar, params):
1627        WPUserDetails.__init__(self, rh)
1628        self._avatar = avatar
1629        self._params = params
1630
1631    def _getTabContent( self, params ):
1632        p = WUserModify( self._avatar )
1633        self._params["postURL"] =  urlHandlers.UHUserModification.getURL()
1634        if self._params["msg"] != "":
1635            self._params["msg"] = "<table bgcolor=\"gray\"><tr><td bgcolor=\"white\">\n<font size=\"+1\" color=\"red\"><b>%s</b></font>\n</td></tr></table>"%self._params["msg"]
1636        return p.getHTML( self._params )
1637
1638
1639class WIdentityModification(wcomponents.WTemplated):
1640
1641    def __init__( self, av, identity=None ):
1642        self._avatar = av
1643        self._identity = identity
1644
1645    def getVars( self ):
1646        vars = wcomponents.WTemplated.getVars( self )
1647
1648        locatorList = ["""<input type="hidden" name="userId" value="%s">"""%self._avatar.getId() ]
1649        if self._identity == None:
1650            WTitle = _("New Identity for user")+" :<br>%s"%(self._avatar.getFullName())
1651            WDescription = ""
1652            login = vars.get("login",self._avatar.getEmail())
1653            password = ""
1654        else:
1655            WTitle, WDescription = "", ""
1656            login = self._identity.getId()
1657            password = ""
1658
1659        vars["login"] = login
1660        vars["password"] = password
1661
1662        if vars.get("WTitle",None) is None :
1663            vars["WTitle"] = WTitle
1664        if vars.get("WDescription",None) is None :
1665            vars["WDescription"] = WDescription
1666        if vars.get("disabledLogin",None) is None :
1667            vars["disabledLogin"] = ""
1668            vars["hiddenLogin"] = ""
1669        else :
1670            vars["hiddenLogin"] = """<input type=hidden name="login" value="%s">"""%vars["login"]
1671        if vars.get("disabledSystem",None) is None :
1672            vars["disabledSystem"] = ""
1673
1674        vars["locator"] = "\n".join(locatorList)
1675        html = ""
1676        am = AuthenticatorMgr()
1677        for auth in am.getList():
1678            html = html + "<option value=" + auth.getId() + ">" + auth.getName() + "</option>\n"
1679        vars["systemList"] = html
1680        return vars
1681
1682
1683class WPIdentityCreation(WPUserDetails):
1684
1685    def __init__(self, rh, av, params):
1686        WPUserDetails.__init__(self, rh)
1687        self._avatar = av
1688        self._params = params
1689
1690    def _getTabContent(self, params):
1691        c = WIdentityModification( self._avatar )
1692        self._params["identityId"] = ""
1693        self._params["postURL"] = urlHandlers.UHUserIdentityCreation.getURL()
1694        return c.getHTML( self._params )
1695
1696
1697class WPIdentityChangePassword(WPUserDetails):
1698
1699    def __init__(self, rh, av, params):
1700        WPUserDetails.__init__(self, rh)
1701        self._avatar = av
1702        self._params = params
1703
1704    def _getTabContent(self, params):
1705
1706        identity = self._avatar.getIdentityById(self._params["identityId"],"Local")
1707        c = WIdentityModification( self._avatar, identity )
1708        postURL = urlHandlers.UHUserIdentityChangePassword.getURL()
1709        self._params["postURL"] = postURL
1710        self._params["WTitle"] = _("Change password for user")+" :<br>%s"%self._avatar.getFullName()
1711        self._params["disabledLogin"] = "disabled"
1712        self._params["disabledSystem"] = "disabled"
1713        self._params["login"] = self._params["identityId"]
1714        return c.getHTML( self._params )
1715
1716
1717
1718class WPGroupCommon(WPUsersAndGroupsCommon):
1719
1720    def __init__( self, rh ):
1721        WPUsersAndGroupsCommon.__init__( self, rh )
1722
1723    def _setActiveTab( self ):
1724        self._subTabGroups.setActive()
1725
1726class WHTMLGroupList(wcomponents.WTemplated):
1727
1728    def __init__(self, groupList):
1729        self._groupList = groupList
1730
1731    def getVars( self ):
1732        vars = wcomponents.WTemplated.getVars( self )
1733        color="white"
1734        ul = []
1735        vars["groupList"] = ""
1736        ul.append( i18nformat("""
1737                        <tr>
1738                            <td bgcolor="white" style="color:black" align="center"><b>%s _("groups")</b></td>
1739                        </tr>
1740                        """)%len(self._groupList))
1741        for g in self._groupList:
1742            if color=="white":
1743                color="#ececec"
1744            else:
1745                color="white"
1746            url = vars["groupDetailsURLGen"]( g )
1747            if g.isObsolete():
1748                obsolete = 'obsolete'
1749            else:
1750                obsolete = ''
1751            ul.append("""<tr>
1752                            <td bgcolor="%s"><a href="%s">%s</a></td>
1753                            <td bgcolor="%s" align="center">%s</td>
1754                         </tr>"""%(color, url, self.htmlText(g.getName()), color, obsolete))
1755        if ul:
1756            vars["groupList"] += "".join( ul )
1757        else:
1758            vars["groupList"] += i18nformat("""<tr>
1759                            <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp; _("No group returned")</span></td></tr>""")
1760        return vars
1761
1762class WBrowseGroups( wcomponents.WTemplated ):
1763
1764    def __init__( self, letter=None ):
1765        self._letter = letter
1766
1767    def getVars( self ):
1768        vars = wcomponents.WTemplated.getVars( self )
1769        gh = user.GroupHolder()
1770        letters = gh.getBrowseIndex()
1771        vars["browseIndex"] = """
1772        <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.disable=1;document.browseForm.submit();return false;">clear</a></span>"""
1773        if self._letter == "all":
1774            vars["browseIndex"] += """
1775        [all] """
1776        else:
1777            vars["browseIndex"] += """
1778        <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='all';document.browseForm.submit();return false;">all</a></span> """
1779        for letter in letters:
1780            if self._letter == letter:
1781                vars["browseIndex"] += """\n[%s] """ % letter
1782            else:
1783                vars["browseIndex"] += """\n<span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='%s';document.browseForm.submit();return false;">%s</a></span> """ % (escape(letter,True),letter)
1784        vars["browseResult"] = ""
1785        res = []
1786        if self._letter != None:
1787            if self._letter != "all":
1788                res = gh.matchFirstLetter(self._letter, forceWithoutExtAuth=False)
1789            else:
1790                res = gh.getValuesToList()
1791            res.sort(utils.sortGroupsByName)
1792            vars["browseResult"] = WHTMLGroupList(res).getHTML(vars)
1793        return vars
1794
1795class WGroupList(wcomponents.WTemplated):
1796
1797    def __init__( self, criteria ):
1798        self._criteria = criteria
1799
1800    def _performSearch( self, criteria ):
1801        gh = user.GroupHolder()
1802        res = gh.match(criteria,forceWithoutExtAuth=True)
1803        return res
1804
1805    def getVars( self ):
1806        vars = wcomponents.WTemplated.getVars( self )
1807        vars["createGroupURL"] = urlHandlers.UHNewGroup.getURL()
1808        vars["nbGroups"] = user.GroupHolder().getLength()
1809        vars["browseGroups"] = WBrowseGroups(vars.get("letter",None)).getHTML(vars)
1810        vars["browseGroupsURL"] = urlHandlers.UHGroups.getURL()
1811        vars["searchGroupsURL"] = urlHandlers.UHGroups.getURL()
1812        vars["groups"] = ""
1813        if self._criteria and self._criteria["name"] != "":
1814            groupList = self._performSearch(self._criteria)
1815            vars["groups"] = WHTMLGroupList(groupList).getHTML(vars)
1816        return vars
1817
1818
1819class WPGroupList(WPGroupCommon):
1820
1821    def __init__(self, rh, params):
1822        WPGroupCommon.__init__(self,rh)
1823        self._params = params
1824
1825    def _getTabContent( self, params ):
1826        criteria = {}
1827        if filter(lambda x: self._params[x], self._params):
1828            criteria["name"] = self._params.get("sName","")
1829        comp = WGroupList(criteria)
1830        self._params["groupDetailsURLGen"]=urlHandlers.UHGroupDetails.getURL
1831        return comp.getHTML(self._params)
1832
1833
1834class WGroupModification(wcomponents.WTemplated):
1835
1836    def __init__( self, group=None ):
1837        self._group = group
1838
1839    def __setNewGroupVars( self, vars={} ):
1840        vars["Wtitle"] = _("Creating a new group")
1841        vars["name"] = ""
1842        vars["email"] = ""
1843        vars["description"] = ""
1844        vars["obsolete"] = False
1845
1846    def __setGroupVars( self, group, vars ):
1847        vars["Wtitle"] = _("Modifying group basic data")
1848        vars["name"] = group.getName()
1849        vars["email"] = group.getEmail()
1850        vars["description"] = group.getDescription()
1851        vars["obsolete"] = group.isObsolete()
1852
1853    def getVars( self ):
1854        vars = wcomponents.WTemplated.getVars( self )
1855        vars["allowModif"] = True
1856        if self._group == None:
1857            self.__setNewGroupVars( vars )
1858            vars["locator"] = ""
1859        else:
1860            self.__setGroupVars( self._group, vars )
1861            vars["locator"] = self._group.getLocator().getWebForm()
1862            if isinstance(self._group, CERNGroup) or \
1863                   isinstance(self._group, user.LDAPGroup):
1864                vars["allowModif"] = False
1865        return vars
1866
1867
1868class WPGroupCreation(WPGroupCommon):
1869
1870    def _getTabContent( self, params ):
1871        comp = WGroupModification()
1872        pars = {"postURL": urlHandlers.UHGroupPerformRegistration.getURL(), \
1873                "backURL": urlHandlers.UHGroups.getURL() }
1874        return comp.getHTML( pars )
1875
1876class WPLDAPGroupCreation(WPGroupCommon):
1877
1878    def _getTabContent( self, params ):
1879        comp = WLDAPGroupModification()
1880        pars = {"postURL": urlHandlers.UHLDAPGroupPerformRegistration.getURL() }
1881        return comp.getHTML( pars )
1882
1883
1884class WPGroupBase( WPGroupCommon ):
1885
1886    def __init__( self, rh, grp ):
1887        WPGroupCommon.__init__( self, rh )
1888        self._group = grp
1889
1890
1891class WGroupDetails(wcomponents.WTemplated):
1892
1893    def __init__( self, group ):
1894        self._group = group
1895
1896    def getVars( self ):
1897        vars = wcomponents.WTemplated.getVars( self )
1898        vars["name"] = self._group.getName()
1899        vars["description"] = self._group.getDescription()
1900        vars["email"] = self._group.getEmail()
1901        vars["membersList"] = wcomponents.WPrincipalTable().getHTML( self._group.getMemberList(),  None, vars["addMembersURL"], vars["removeMembersURL"], selectable=False )
1902        vars["locator"] = self._group.getLocator().getWebForm()
1903        vars["obsolete"] = self._group.isObsolete()
1904        return vars
1905
1906
1907class WPGroupDetails( WPGroupBase ):
1908
1909    def _getTabContent( self, params ):
1910        c = WGroupDetails( self._group )
1911        pars = { \
1912    "modifyURL": urlHandlers.UHGroupModification.getURL( self._group ),\
1913    "detailsURLGen": urlHandlers.UHPrincipalDetails.getURL, \
1914    "addMembersURL": urlHandlers.UHGroupSelectMembers.getURL(self._group),\
1915    "removeMembersURL": urlHandlers.UHGroupRemoveMembers.getURL(self._group), \
1916    "backURL": urlHandlers.UHGroups.getURL() }
1917        return c.getHTML( pars )
1918
1919
1920class WPGroupModificationBase( WPGroupBase ):
1921    pass
1922
1923
1924class WLDAPGroupModification(wcomponents.WTemplated):
1925
1926    def __init__( self, group=None ):
1927        self._group = group
1928
1929    def __setNewGroupVars( self, vars={} ):
1930        vars["Wtitle"] = _("Creating a new LDAP group")
1931        vars["name"] = ""
1932        vars["description"] = ""
1933
1934    def __setGroupVars( self, group, vars ):
1935        vars["Wtitle"] = _("Modifying LDAP group basic data")
1936        vars["name"] = group.getName()
1937        vars["description"] = group.getDescription()
1938
1939    def getVars( self ):
1940        vars = wcomponents.WTemplated.getVars( self )
1941        if self._group == None:
1942            self.__setNewGroupVars( vars )
1943            vars["locator"] = ""
1944        else:
1945            self.__setGroupVars( self._group, vars )
1946            vars["locator"] = self._group.getLocator().getWebForm()
1947        return vars
1948
1949
1950class WPGroupModification( WPGroupModificationBase ):
1951
1952    def _getTabContent( self, params ):
1953        comp = WGroupModification( self._group )
1954        params["postURL"] = urlHandlers.UHGroupPerformModification.getURL()
1955        params["backURL"] = urlHandlers.UHGroupDetails.getURL( self._group )
1956        return comp.getHTML( params )
1957
1958
1959class WPGroupSelectMembers( WPGroupModificationBase ):
1960
1961    def _getTabContent( self, params ):
1962        searchExt = params.get("searchExt","")
1963
1964        if searchExt != "":
1965            searchLocal = False
1966        else:
1967            searchLocal = True
1968        comp = wcomponents.WPrincipalSelection( urlHandlers.UHGroupSelectMembers.getURL(),forceWithoutExtAuth=searchLocal )
1969        params["addURL"] = urlHandlers.UHGroupAddMembers.getURL()
1970        return comp.getHTML( params )
1971
1972
1973class WPSelectUserToLogAs(WPUserCommon ):
1974
1975#    def _getTabContent( self, params ):
1976#        wc = WSelectUserToLogAs()
1977#        pars = {"submitURL":urlHandlers.UHLogMeAs.getURL()}
1978#        return wc.getHTML( pars )
1979
1980    def _getTabContent( self, params ):
1981        searchURL = urlHandlers.UHLogMeAs.getURL()
1982        #cancelURL = urlHandlers.UHUsers.getURL()
1983        wc = wcomponents.WUserSelection( searchURL, multi=False, forceWithoutExtAuth=True )
1984        wc.setTitle(_("Select user to log in as"))
1985        params["addURL"] =  urlHandlers.UHLogMeAs.getURL()
1986
1987        return wc.getHTML( params )
1988
1989
1990
1991
1992class WPUserMerge( WPUserCommon ):
1993
1994    def __init__(self, rh, prin, toMerge):
1995        WPUserCommon.__init__(self, rh)
1996        self.prin = prin
1997        self.toMerge = toMerge
1998
1999    def _getTabContent( self, params ):
2000        wc = WUserMerge(self.prin, self.toMerge)
2001        pars = {"submitURL":urlHandlers.UHUserMerge.getURL()}
2002        return wc.getHTML( pars )
2003
2004class WUserMerge(wcomponents.WTemplated):
2005
2006    def __init__(self, prin, toMerge):
2007        self.prin = prin
2008        self.toMerge = toMerge
2009
2010    def getVars( self ):
2011        vars = wcomponents.WTemplated.getVars( self )
2012        vars["prinId"] = ""
2013        vars["ptitle"] = ""
2014        vars["pname"] = ""
2015        vars["pfirstName"] = ""
2016        vars["porganisation"] = ""
2017        vars["pemail"] = ""
2018        vars["paddress"] = ""
2019        vars["ptelephone"] = ""
2020        vars["pfax"] = ""
2021        vars["plogins"] = ""
2022        vars["toMergeId"] = ""
2023        vars["mtitle"] = ""
2024        vars["mname"] = ""
2025        vars["mfirstName"] = ""
2026        vars["morganisation"] = ""
2027        vars["memail"] = ""
2028        vars["maddress"] = ""
2029        vars["mtelephone"] = ""
2030        vars["mfax"] = ""
2031        vars["mlogins"] = ""
2032
2033        if self.prin:
2034            vars["prinId"] = self.prin.getId()
2035            vars["ptitle"] = self.prin.getTitle()
2036            vars["pname"] = self.prin.getSurName()
2037            vars["pfirstName"] = self.prin.getName()
2038            vars["porganisation"] = self.prin.getOrganisation()
2039            vars["pemail"] = "<br>".join(self.prin.getEmails())
2040            vars["paddress"] = self.prin.getAddress()
2041            vars["ptelephone"] = self.prin.getTelephone()
2042            vars["pfax"] = self.prin.getFax()
2043            il = ["<table>"]
2044            for item in self.prin.getIdentityList():
2045                il.append("""
2046                            <tr>
2047                                <td width="60%%">
2048                                    %s
2049                                </td>
2050                                <td width="20%%">
2051                                    <small>%s</small>
2052                                </td>
2053                            </tr>
2054                            """%(item.getLogin(), item.getAuthenticatorTag()) )
2055            il.append("</table>")
2056            vars["plogins"] = "".join( il )
2057
2058        if self.toMerge:
2059            vars["toMergeId"] = self.toMerge.getId()
2060            vars["mtitle"] = self.toMerge.getTitle()
2061            vars["mname"] = self.toMerge.getSurName()
2062            vars["mfirstName"] = self.toMerge.getName()
2063            vars["morganisation"] = self.toMerge.getOrganisation()
2064            vars["memail"] = "<br>".join(self.toMerge.getEmails())
2065            vars["maddress"] = self.toMerge.getAddress()
2066            vars["mtelephone"] = self.toMerge.getTelephone()
2067            vars["mfax"] = self.toMerge.getFax()
2068            il = ["<table>"]
2069            for item in self.toMerge.getIdentityList():
2070                il.append("""
2071                            <tr>
2072                                <td width="60%%">
2073                                    %s
2074                                </td>
2075                                <td width="20%%">
2076                                    <small>%s</small>
2077                                </td>
2078                            </tr>
2079                            """%(item.getLogin(), item.getAuthenticatorTag()) )
2080            il.append("</table>")
2081            vars["mlogins"] = "".join( il )
2082
2083
2084
2085        return vars
2086
2087class WPUserMergeSelectPrin(WPUserMerge):
2088
2089    def _getTabContent( self, params ):
2090        searchURL = urlHandlers.UHUserMerge.getURL()
2091        #searchURL.addParam("selectPrin", "sp")
2092        addURL = urlHandlers.UHUserMerge.getURL()
2093        addURL.addParam("setPrin", "setPrin")
2094        #cancelURL = urlHandlers.UHUserMerge.getURL()
2095        wc = wcomponents.WUserSelection( searchURL, multi=False, forceWithoutExtAuth=True )
2096        wc.setTitle("Select user")
2097        params["addURL"] =  addURL
2098        html = i18nformat("""<table align="center" width="95%%">
2099    <tr>
2100       <td class="formTitle"> _("General admin data")</td>
2101    </tr>
2102    <tr>
2103        <td>
2104            <br>
2105        """)
2106        html = "%s%s"%(html,wc.getHTML( params ))
2107        return "%s%s"%(html,"""</td></tr></table>""")
2108
2109class WPUserMergeSelectToMerge(WPUserMerge):
2110
2111    def _getTabContent( self, params ):
2112        searchURL = urlHandlers.UHUserMerge.getURL()
2113        #searchURL.addParam("selectToMerge", "sp")
2114        addURL = urlHandlers.UHUserMerge.getURL()
2115        addURL.addParam("setToMerge", "setToMerge")
2116        #cancelURL = urlHandlers.UHUserMerge.getURL()
2117        wc = wcomponents.WUserSelection( searchURL, multi=False, forceWithoutExtAuth=True )
2118        wc.setTitle("Select user")
2119        params["addURL"] =  addURL
2120        html = i18nformat("""<table align="center" width="95%%">
2121    <tr>
2122       <td class="formTitle"> _("General admin data")</td>
2123    </tr>
2124    <tr>
2125        <td>
2126            <br>
2127        """)
2128        html = "%s%s"%(html,wc.getHTML( params ))
2129        return "%s%s"%(html,"""</td></tr></table>""")
2130
2131class WPRoomsBase( WPAdminsBase ):
2132    def _setActiveSideMenuItem(self):
2133        self._roomsMenuItem.setActive()
2134
2135    def _createTabCtrl( self ):
2136        self._tabCtrl = wcomponents.TabControl()
2137
2138        if self._rh._getUser().isAdmin():
2139            self._subTabRoomBooking = self._tabCtrl.newTab( "booking", _("Room Booking"), \
2140                    urlHandlers.UHRoomBookingPluginAdmin.getURL() )
2141            self._subTabMain = self._subTabRoomBooking.newSubTab( "main", _("Main"), \
2142                    urlHandlers.UHRoomBookingPluginAdmin.getURL() )
2143        else:
2144            self._subTabRoomBooking = self._tabCtrl.newTab( "booking", _("Room Booking"), \
2145                    urlHandlers.UHRoomBookingAdmin.getURL() )
2146        self._subTabConfig = self._subTabRoomBooking.newSubTab( "configuration", _("Configuration"), \
2147                urlHandlers.UHRoomBookingAdmin.getURL() )
2148        self._subTabRoomMappers = self._tabCtrl.newTab( "mappers", _("Room Mappers"), \
2149                urlHandlers.UHRoomMappers.getURL() )
2150
2151    def _getNavigationDrawer(self):
2152        if self._rh._getUser().isAdmin():
2153            return wcomponents.WSimpleNavigationDrawer(_("Room Booking Admin"), urlHandlers.UHRoomBookingPluginAdmin.getURL, bgColor="white")
2154        return wcomponents.WSimpleNavigationDrawer(_("Room Booking Admin"), urlHandlers.UHRoomBookingAdmin.getURL, bgColor="white")
2155
2156    def _getPageContent(self, params):
2157        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
2158
2159class WPRoomMapperBase( WPRoomsBase ):
2160
2161    def __init__( self, rh ):
2162        WPRoomsBase.__init__( self, rh )
2163
2164    def _setActiveTab( self ):
2165        self._subTabRoomMappers.setActive()
2166
2167class WRoomMapperList(wcomponents.WTemplated):
2168
2169    def __init__( self, criteria ):
2170        self._criteria = criteria
2171
2172    def _performSearch( self, criteria ):
2173        rmh = roomMapping.RoomMapperHolder()
2174        res = rmh.match(criteria)
2175        return res
2176
2177    def getVars( self ):
2178        vars = wcomponents.WTemplated.getVars( self )
2179        vars["createRoomMapperURL"] = urlHandlers.UHNewRoomMapper.getURL()
2180        vars["searchRoomMappersURL"] = urlHandlers.UHRoomMappers.getURL()
2181        vars["roomMappers"] = ""
2182        if self._criteria:
2183            vars["roomMappers"] = """<tr>
2184                              <td>
2185                    <br>
2186                <table width="100%%" align="left" style="border-top: 1px solid #777777; padding-top:10px">"""
2187            roomMapperList = self._performSearch(self._criteria)
2188            ul = []
2189            color="white"
2190            ul = []
2191            for rm in roomMapperList:
2192                if color=="white":
2193                    color="#F6F6F6"
2194                else:
2195                    color="white"
2196                url = vars["roomMapperDetailsURLGen"]( rm )
2197                ul.append("""<tr>
2198                                <td bgcolor="%s"><a href="%s">%s</a></td>
2199                            </tr>"""%(color, url, rm.getName() ) )
2200            if ul:
2201                vars["roomMappers"] += "".join( ul )
2202            else:
2203                vars["roomMappers"] += i18nformat("""<tr>
2204                            <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp; _("No room mappers for this search")</span></td></tr>""")
2205            vars["roomMappers"] += """    </table>
2206                      </td>
2207                </tr>"""
2208        return vars
2209
2210
2211class WPRoomMapperList( WPRoomMapperBase ):
2212
2213    def __init__( self, rh, params ):
2214        WPRoomMapperBase.__init__( self, rh )
2215        self._params = params
2216
2217    def _getTabContent( self, params ):
2218        criteria = {}
2219        if filter(lambda x: self._params[x], self._params):
2220            criteria["name"] = self._params.get("sName","")
2221        comp = WRoomMapperList(criteria)
2222        pars = {"roomMapperDetailsURLGen": urlHandlers.UHRoomMapperDetails.getURL }
2223        return comp.getHTML(pars)
2224
2225
2226class WRoomMapperDetails(wcomponents.WTemplated):
2227
2228    def __init__( self, rm):
2229        self._roomMapper = rm
2230
2231    def getVars( self ):
2232        vars = wcomponents.WTemplated.getVars( self )
2233        vars["name"] = self._roomMapper.getName()
2234        vars["description"] = self._roomMapper.getDescription()
2235        vars["url"] = self._roomMapper.getBaseMapURL()
2236        vars["placeName"] = self._roomMapper.getPlaceName()
2237        vars["regexps"] = "<ul><li>%s</li></ul>"%"</li><li>".join(self._roomMapper.getRegularExpressions())
2238        return vars
2239
2240
2241class WPRoomMapperDetails( WPRoomMapperBase ):
2242
2243    def __init__(self, rh, roomMapper):
2244        WPRoomMapperBase.__init__(self, rh)
2245        self._roomMapper = roomMapper
2246
2247    def _getTabContent( self, params ):
2248        comp = WRoomMapperDetails( self._roomMapper )
2249        pars = {"modifyURL": urlHandlers.UHRoomMapperModification.getURL( self._roomMapper ) }
2250        return comp.getHTML( pars )
2251
2252
2253class WRoomMapperEdit(wcomponents.WTemplated):
2254
2255    def __init__( self, rm=None ):
2256        self._roomMapper = rm
2257
2258    def getVars( self ):
2259        vars = wcomponents.WTemplated.getVars( self )
2260        vars["name"] = ""
2261        vars["description"] = ""
2262        vars["url"] = ""
2263        vars["placeName"] = ""
2264        vars["regexps"] = ""
2265        vars["locator"] = ""
2266        if self._roomMapper:
2267            vars["name"] = self._roomMapper.getName()
2268            vars["description"] = self._roomMapper.getDescription()
2269            vars["url"] = self._roomMapper.getBaseMapURL()
2270            vars["placeName"] = self._roomMapper.getPlaceName()
2271            vars["regexps"] = "\r\n".join(self._roomMapper.getRegularExpressions())
2272            vars["locator"] = self._roomMapper.getLocator().getWebForm()
2273        return vars
2274
2275
2276class WPRoomMapperModification( WPRoomMapperBase ):
2277
2278    def __init__(self, rh, domain):
2279        WPRoomMapperBase.__init__(self, rh)
2280        self._domain = domain
2281
2282    def _getTabContent( self, params ):
2283        comp = WRoomMapperEdit( self._domain )
2284        pars = {"postURL": urlHandlers.UHRoomMapperPerformModification.getURL() }
2285        return comp.getHTML( pars )
2286
2287
2288class WPRoomMapperCreation( WPRoomMapperBase ):
2289
2290    def _getTabContent( self, params ):
2291        comp = WRoomMapperEdit()
2292        pars = {"postURL": urlHandlers.UHRoomMapperPerformCreation.getURL()}
2293        return comp.getHTML( pars )
2294
2295
2296
2297class WPDomainBase( WPAdminsBase ):
2298
2299    def __init__( self, rh ):
2300        WPAdminsBase.__init__( self, rh )
2301
2302    def _setActiveSideMenuItem( self ):
2303        self._domainsMenuItem.setActive()
2304
2305class WBrowseDomains( wcomponents.WTemplated ):
2306
2307    def __init__( self, letter=None ):
2308        self._letter = letter
2309
2310    def getVars( self ):
2311        vars = wcomponents.WTemplated.getVars( self )
2312        dh = domain.DomainHolder()
2313        letters = dh.getBrowseIndex()
2314        vars["browseIndex"] = i18nformat("""
2315        <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.disable=1;document.browseForm.submit();return false;">_("clear")</a></span>""")
2316        if self._letter == "all":
2317            vars["browseIndex"] += """
2318        [all] """
2319        else:
2320            vars["browseIndex"] += i18nformat("""
2321        <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='all';document.browseForm.submit();return false;">_("all")</a></span> """)
2322        for letter in letters:
2323            if self._letter == letter:
2324                vars["browseIndex"] += """\n[%s] """ % letter
2325            else:
2326                vars["browseIndex"] += """\n<span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='%s';document.browseForm.submit();return false;">%s</a></span> """ % (escape(letter,True),letter)
2327        vars["browseResult"] = ""
2328        res = []
2329        if self._letter not in [ None, "" ]:
2330            if self._letter != "all":
2331                res = dh.matchFirstLetter(self._letter)
2332            else:
2333                res = dh.getValuesToList()
2334            res.sort(utils.sortDomainsByName)
2335            vars["browseResult"] = WHTMLDomainList(vars,res).getHTML()
2336        return vars
2337
2338class WDomainList(wcomponents.WTemplated):
2339
2340    def __init__( self, criteria, params ):
2341        self._criteria = criteria
2342        self._params = params
2343
2344    def _performSearch( self, criteria ):
2345        dh = domain.DomainHolder()
2346        res = dh.match(criteria)
2347        return res
2348
2349    def getVars( self ):
2350        vars = wcomponents.WTemplated.getVars( self )
2351        vars["createDomainURL"] = urlHandlers.UHNewDomain.getURL()
2352        vars["nbDomains"] = domain.DomainHolder().getLength()
2353        vars["browseDomains"] = WBrowseDomains(self._params.get("letter",None)).getHTML(vars)
2354        vars["browseDomainsURL"] = urlHandlers.UHDomains.getURL()
2355        vars["searchDomainsURL"] = urlHandlers.UHDomains.getURL()
2356        vars["domains"] = ""
2357        if self._criteria:
2358            domainList = self._performSearch(self._criteria)
2359            vars["domains"] = WHTMLDomainList(vars,domainList).getHTML()
2360        return vars
2361
2362class WHTMLDomainList:
2363
2364    def __init__(self, vars, list):
2365        self._vars = vars
2366        self._list = list
2367
2368    def getHTML(self):
2369        text = """<tr>
2370                              <td>
2371                    <br>
2372                <table width="100%%" align="left" style="border-top: 1px solid #777777; padding-top:10px">"""
2373        color="white"
2374        ul = []
2375        for dom in self._list:
2376            if color=="white":
2377                color="#F6F6F6"
2378            else:
2379                color="white"
2380            url = self._vars["domainDetailsURLGen"]( dom )
2381            ul.append("""<tr>
2382                            <td bgcolor="%s"><a href="%s">%s</a></td>
2383                        </tr>"""%(color, url, dom.getName() ) )
2384        if ul:
2385            text += "".join( ul )
2386        else:
2387            text += """<tr>
2388                        <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp;No domains for this search</span></td></tr>"""
2389        text += """    </table>
2390                      </td>
2391                </tr>"""
2392        return text
2393
2394class WPDomainList( WPDomainBase ):
2395
2396    def __init__( self, rh, params ):
2397        WPDomainBase.__init__( self, rh )
2398        self._params = params
2399
2400    def _getPageContent( self, params ):
2401        criteria = {}
2402        if self._params.get("sName","") != "":
2403            criteria["name"] = self._params.get("sName","")
2404        comp = WDomainList(criteria,self._params)
2405        pars = {"domainDetailsURLGen": urlHandlers.UHDomainDetails.getURL }
2406        return comp.getHTML(pars)
2407
2408
2409class WDomainDetails(wcomponents.WTemplated):
2410
2411    def __init__( self, dom):
2412        self._domain = dom
2413
2414    def getVars( self ):
2415        vars = wcomponents.WTemplated.getVars( self )
2416        vars["name"] = self._domain.getName()
2417        vars["description"] = self._domain.getDescription()
2418        vars["filters"] = "<br>".join(self._domain.getFilterList())
2419        return vars
2420
2421
2422class WPDomainDetails( WPDomainBase ):
2423
2424    def __init__(self, rh, domain):
2425        WPDomainBase.__init__(self, rh)
2426        self._domain = domain
2427
2428    def _getPageContent( self, params ):
2429        comp = WDomainDetails( self._domain )
2430        pars = {"modifyURL": urlHandlers.UHDomainModification.getURL( self._domain ) }
2431        return comp.getHTML( pars )
2432
2433
2434class WDomainDataModification(wcomponents.WTemplated):
2435
2436    def __init__( self, dom ):
2437        self._domain = dom
2438
2439    def getVars( self ):
2440        vars = wcomponents.WTemplated.getVars( self )
2441        vars["name"] = self._domain.getName()
2442        vars["description"] = self._domain.getDescription()
2443        vars["filters"] = ";".join( self._domain.getFilterList() )
2444        vars["locator"] = self._domain.getLocator().getWebForm()
2445        return vars
2446
2447
2448class WPDomainModification( WPDomainBase ):
2449
2450    def __init__(self, rh, domain):
2451        WPDomainBase.__init__(self, rh)
2452        self._domain = domain
2453
2454    def _getPageContent( self, params ):
2455        comp = WDomainDataModification( self._domain )
2456        pars = {"postURL": urlHandlers.UHDomainPerformModification.getURL() }
2457        return comp.getHTML( pars )
2458
2459
2460class WDomainCreation(wcomponents.WTemplated):
2461    pass
2462
2463
2464class WPDomainCreation( WPDomainBase ):
2465
2466    def _getPageContent( self, params ):
2467        comp = WDomainCreation()
2468        pars = {"postURL": urlHandlers.UHDomainPerformCreation.getURL()}
2469        return comp.getHTML( pars )
2470
2471
2472
2473# Room Booking Module ========================================
2474
2475
2476class WPRoomBookingPluginAdminBase( WPRoomsBase ):
2477
2478    def __init__( self, rh ):
2479        WPRoomsBase.__init__( self, rh )
2480
2481    def getJSFiles(self):
2482        return WPRoomsBase.getJSFiles(self) + \
2483               self._includeJSPackage('Management')
2484
2485    def _setActiveTab( self ):
2486        self._subTabRoomBooking.setActive()
2487
2488    def _getSiteArea(self):
2489        return 'Room Booking Administration'
2490
2491class WPRoomBookingPluginAdmin( WPRoomBookingPluginAdminBase ):
2492
2493    def __init__( self, rh, params ):
2494        WPRoomBookingPluginAdminBase.__init__( self, rh )
2495        self._params = params
2496
2497    def _setActiveTab( self ):
2498        WPRoomBookingPluginAdminBase._setActiveTab( self )
2499        self._subTabMain.setActive()
2500
2501    def _getTabContent( self, params ):
2502        wc = WRoomBookingPluginAdmin( self._rh )
2503        return wc.getHTML( params )
2504
2505class WRoomBookingPluginAdmin( wcomponents.WTemplated ):
2506
2507    def __init__( self, rh ):
2508        self._rh = rh
2509
2510    def getVars( self ):
2511        vars = wcomponents.WTemplated.getVars( self )
2512        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
2513
2514        iconDisabled = str(Config.getInstance().getSystemIconURL( "disabledSection" ))
2515        iconEnabled = str(Config.getInstance().getSystemIconURL( "enabledSection" ))
2516        if minfo.getRoomBookingModuleActive():
2517            vars["iconURL"] = iconEnabled
2518            vars["activationText"] = _("Click to DEACTIVATE Room Booking Module")
2519        else:
2520            vars["iconURL"] = iconDisabled
2521            vars["activationText"] = _("Click to ACTIVATE Room Booking Module")
2522        rbPlugins = PluginLoader.getPluginsByType("RoomBooking")
2523        vars["plugins"] = rbPlugins
2524        vars["zodbHost"] = self._rh._host
2525        vars["zodbPort"] = self._rh._port
2526        vars["zodbRealm"] = self._rh._realm
2527        vars["zodbUser"] = self._rh._user
2528        vars["zodbPassword"] = self._rh._password
2529
2530        return vars
2531
2532
2533class WPRoomBookingRoomForm( WPRoomBookingPluginAdminBase ):
2534
2535    _userData = ['favorite-user-list']
2536
2537    def __init__( self, rh ):
2538        self._rh = rh
2539        WPRoomBookingPluginAdminBase.__init__( self, rh )
2540
2541    def _setActiveTab( self ):
2542        WPRoomBookingPluginAdminBase._setActiveTab( self )
2543        self._subTabConfig.setActive()
2544
2545    def _getTabContent( self, params ):
2546        wc = wcomponents.WRoomBookingRoomForm( self._rh )
2547        return wc.getHTML( params )
2548
2549class WPRoomBookingAdmin( WPRoomBookingPluginAdminBase ):
2550
2551    def __init__( self, rh ):
2552        self._rh = rh
2553        WPRoomBookingPluginAdminBase.__init__( self, rh )
2554
2555    def _setActiveTab( self ):
2556        self._subTabConfig.setActive()
2557
2558    def _getTabContent( self, params ):
2559        wc = wcomponents.WRoomBookingAdmin( self._rh )
2560        return wc.getHTML( params )
2561
2562class WPRoomBookingAdminLocation( WPRoomBookingPluginAdminBase ):
2563
2564    def __init__( self, rh, location, actionSucceeded = False ):
2565        self._rh = rh
2566        self._location = location
2567        self._actionSucceeded = actionSucceeded
2568        WPRoomBookingPluginAdminBase.__init__( self, rh )
2569
2570    def _setActiveTab( self ):
2571        self._subTabConfig.setActive()
2572
2573    def _getTabContent( self, params ):
2574        wc = wcomponents.WRoomBookingAdminLocation( self._rh, self._location )
2575        params['actionSucceeded'] = self._actionSucceeded
2576        return wc.getHTML( params )
2577
2578class WPAdminsSystemBase(WPAdminsBase):
2579    def __init__( self, rh ):
2580        WPAdminsBase.__init__( self, rh )
2581
2582    def _setActiveSideMenuItem(self):
2583        self._systemMenuItem.setActive()
2584
2585    def _createTabCtrl( self ):
2586        self._tabCtrl = wcomponents.TabControl()
2587
2588        self._subTabConfiguration = self._tabCtrl.newTab( "configuration", _("Configuration"), \
2589                urlHandlers.UHAdminsSystem.getURL() )
2590        self._subTabTaskManager = self._tabCtrl.newTab( "tasks", _("Task Manager"), \
2591                urlHandlers.UHTaskManager.getURL() )
2592        self._subTabMaintenance = self._tabCtrl.newTab( "maintenance", _("Maintenance"), \
2593                urlHandlers.UHMaintenance.getURL() )
2594
2595    def _getPageContent(self, params):
2596        return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
2597
2598class WPAdminsSystem(WPAdminsSystemBase):
2599
2600    def _setActiveTab( self ):
2601        self._subTabConfiguration.setActive()
2602
2603    def _getTabContent( self, params ):
2604        wc = WAdminsSystem()
2605        return wc.getHTML( params )
2606
2607class WAdminsSystem(wcomponents.WTemplated):
2608
2609    def getVars( self ):
2610        vars = wcomponents.WTemplated.getVars( self )
2611        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
2612        vars["minfo"] = minfo
2613        vars["ModifURL"] = urlHandlers.UHAdminsSystemModif.getURL()
2614        return vars
2615
2616class WPAdminsSystemModif(WPAdminsSystemBase):
2617
2618    def _getTabContent( self, params ):
2619        wc = WAdminsSystemModif()
2620        return wc.getHTML( params )
2621
2622class WAdminsSystemModif(wcomponents.WTemplated):
2623
2624    def getVars( self ):
2625        vars = wcomponents.WTemplated.getVars( self )
2626        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
2627        vars["minfo"] = minfo
2628        vars["postURL"] = urlHandlers.UHAdminsSystemModif.getURL()
2629        return vars
2630
2631class WPMaintenanceBase( WPAdminsSystemBase ):
2632
2633    def __init__( self, rh ):
2634        WPAdminsBase.__init__( self, rh )
2635
2636    def _setActiveTab( self ):
2637        self._subTabMaintenance.setActive()
2638
2639class WPMaintenance( WPMaintenanceBase ):
2640
2641    def __init__(self, rh, s, dbSize, nWebsessions):
2642        WPMaintenanceBase.__init__(self, rh)
2643        self._stat = s
2644        self._dbSize = dbSize
2645        self._nWebsessions = nWebsessions
2646
2647    def _getTabContent( self, params ):
2648        wc = WAdminMaintenance()
2649        pars = { "cleanupURL": urlHandlers.UHMaintenanceTmpCleanup.getURL(), \
2650                 "tempSize": self._stat[0], \
2651                 "nFiles": "%s files"%self._stat[1], \
2652                 "nDirs": "%s folders"%self._stat[2], \
2653                 "packURL": urlHandlers.UHMaintenancePack.getURL(), \
2654                 "dbSize": self._dbSize, \
2655                 "websessionCleanupURL": urlHandlers.UHMaintenanceWebsessionCleanup.getURL(), \
2656                 "nWebsessions": self._nWebsessions}
2657        return wc.getHTML( pars )
2658
2659class WAdminMaintenance(wcomponents.WTemplated):
2660
2661    def getVars( self ):
2662        vars = wcomponents.WTemplated.getVars( self )
2663        return vars
2664
2665class WPMaintenanceTmpCleanup(WPMaintenanceBase):
2666
2667    def __init__(self,rh):
2668        WPMaintenanceBase.__init__(self,rh)
2669
2670    def _getTabContent(self,params):
2671        wc=wcomponents.WConfirmation()
2672        msg="""Are you sure you want to delete the temporary directory
2673        (note that all the files in that directory will be deleted)?"""
2674        url=urlHandlers.UHMaintenancePerformTmpCleanup.getURL()
2675        return """
2676                <table align="center" width="95%%">
2677                    <tr>
2678                        <td class="formTitle">Maintenance: Cleaning-up temporary directory</td>
2679                    </tr>
2680                    <tr>
2681                        <td>
2682                            <br>
2683                            %s
2684                        </td>
2685                    </tr>
2686                </table>
2687                """%wc.getHTML(msg,url,{})
2688
2689class WPMaintenancePack(WPMaintenanceBase):
2690
2691    def __init__(self,rh):
2692        WPMaintenanceBase.__init__(self,rh)
2693
2694    def _getTabContent(self,params):
2695        wc=wcomponents.WConfirmation()
2696        msg="""Are you sure you want to pack the database?"""
2697        url=urlHandlers.UHMaintenancePerformPack.getURL()
2698        return """
2699                <table align="center" width="95%%">
2700                    <tr>
2701                        <td class="formTitle">Maintenance: Database packing</td>
2702                    </tr>
2703                    <tr>
2704                        <td>
2705                            <br>
2706                            %s
2707                        </td>
2708                    </tr>
2709                </table>
2710                """%wc.getHTML(msg,url,{})
2711
2712class WPMaintenanceWebsessionCleanup(WPMaintenanceBase):
2713
2714    def __init__(self,rh):
2715        WPMaintenanceBase.__init__(self,rh)
2716
2717    def _getTabContent(self,params):
2718        wc=wcomponents.WConfirmation()
2719        msg="""Are you sure you want to delete all the web sessions?"""
2720        url=urlHandlers.UHMaintenancePerformWebsessionCleanup.getURL()
2721        return """
2722                <table align="center" width="95%%">
2723                    <tr>
2724                        <td class="formTitle">Maintenance: Cleaning-up websession</td>
2725                    </tr>
2726                    <tr>
2727                        <td>
2728                            <br>
2729                            %s
2730                        </td>
2731                    </tr>
2732                </table>
2733                """%wc.getHTML(msg,url,{})
2734
2735
2736class WPTaskManagerBase(WPAdminsSystemBase):
2737
2738    def __init__( self, rh ):
2739        WPAdminsBase.__init__( self, rh )
2740
2741    def _setActiveTab( self ):
2742        self._subTabTaskManager.setActive()
2743
2744class WPTaskManager( WPTaskManagerBase ):
2745
2746    def _getTabContent( self, params ):
2747        wc = WTaskManager()
2748
2749        pars = {}
2750        return wc.getHTML(pars)
2751
2752
2753class WTaskManager(wcomponents.WTemplated):
2754    pass
2755
2756
2757class WPConfirmDelete(WPTaskManagerBase):
2758
2759    def __init__(self, req, taskId):
2760        WPTaskManagerBase.__init__(self, req)
2761        self._taskId = taskId
2762
2763    def _getTabContent( self, params ):
2764        wc = wcomponents.WConfirmation()
2765        msg="""Are you sure you want to delete the following task?<br><ul>%s</ul>
2766        <font color="red">(note you will permanently remove the task )</font><br>"""%(self._taskId)
2767        postURL = urlHandlers.UHRemoveTask.getURL()
2768        return wc.getHTML( msg, postURL, {"taskId":self._taskId} )
2769
2770class WPOAIPrivateConfig( WPServicesCommon ):
2771
2772    def __init__( self, rh, addedIP=None ):
2773        WPServicesCommon.__init__( self, rh )
2774        self._addedIP = addedIP
2775
2776    def _getTabContent( self, params ):
2777        wc = WOAIPrivateConfig()
2778        params["addedIP"] = self._addedIP
2779        return wc.getHTML( params )
2780
2781    def _setActiveTab( self ):
2782        self._subTabOAIPrivateConfig.setActive()
2783
2784class WOAIPrivateConfig(wcomponents.WTemplated):
2785
2786    def getVars( self ):
2787        vars = wcomponents.WTemplated.getVars( self )
2788        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
2789        vars["ipList"] = minfo.getOAIPrivateHarvesterList()
2790        vars["removeIcon"] = Config.getInstance().getSystemIconURL( "remove" )
2791        return vars
Note: See TracBrowser for help on using the repository browser.