indico/MaKaC/webinterface/pages/admins.py

   1 # This file is part of Indico.
   2 # Copyright (C) 2002 - 2015 European Organization for Nuclear Research (CERN).
   3 #
   4 # Indico is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU General Public License as
   6 # published by the Free Software Foundation; either version 3 of the
   7 # License, or (at your option) any later version.
   8 #
   9 # Indico is distributed in the hope that it will be useful, but
  10 # WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with Indico; if not, see <http://www.gnu.org/licenses/>.
  16
  17 import os
  18 import re
  19 from cgi import escape
  20 from operator import methodcaller
  21
  22 from pytz import timezone
  23
  24 # MaKaC
  25 import MaKaC.common.info as info
  26 import MaKaC.conference as conference
  27 import MaKaC.webinterface.pages.conferences as conferences
  28 import MaKaC.webinterface.urlHandlers as urlHandlers
  29 import MaKaC.webinterface.wcomponents as wcomponents
  30 from MaKaC import domain
  31 from MaKaC.common import timezoneUtils, utils
  32 from MaKaC.common.Announcement import getAnnoucementMgrInstance
  33 from MaKaC.common.fossilize import fossilize
  34 from MaKaC.fossils.modules import INewsItemFossil
  35 from MaKaC.i18n import _
  36 from MaKaC.webinterface.pages.conferences import WConfModifBadgePDFOptions
  37 from MaKaC.webinterface.pages.main import WPMainBase
  38
  39 # indico
  40 from indico.core import signals
  41 from indico.core.config import Config
  42 from indico.modules import ModuleHolder
  43 from indico.modules.users import User
  44 from indico.util.i18n import i18nformat, get_all_locales
  45 from indico.util.signals import values_from_signal
  46 from indico.web.flask.util import url_for
  47
  48
  49 class WPAdminsBase(WPMainBase):
  50
  51     _userData = ['favorite-user-ids']
  52
  53     def _getSiteArea(self):
  54         return "AdministrationArea"
  55
  56     def getCSSFiles(self):
  57         return WPMainBase.getCSSFiles(self) + self._asset_env['admin_sass'].urls()
  58
  59     def getJSFiles(self):
  60         return WPMainBase.getJSFiles(self) + \
  61                self._includeJSPackage('Admin') + \
  62                self._includeJSPackage('Management')
  63
  64     def _getHeader( self ):
  65         """
  66         """
  67         wc = wcomponents.WHeader( self._getAW() )
  68         return wc.getHTML( { "subArea": self._getSiteArea(), \
  69                              "loginURL": self._escapeChars(str(self.getLoginURL())),\
  70                              "logoutURL": self._escapeChars(str(self.getLogoutURL())), \
  71                              "tabControl": self._getTabControl() } )
  72
  73     def _createSideMenu(self):
  74         self._sideMenu = wcomponents.ManagementSideMenu()
  75
  76         mainSection = wcomponents.SideMenuSection()
  77
  78         self._generalSettingsMenuItem = wcomponents.SideMenuItem(_("General settings"),
  79             urlHandlers.UHAdminArea.getURL())
  80         mainSection.addItem( self._generalSettingsMenuItem)
  81
  82         self._domainsMenuItem = wcomponents.SideMenuItem(_("IP Domains"),
  83             urlHandlers.UHDomains.getURL())
  84         mainSection.addItem( self._domainsMenuItem)
  85
  86         self._templatesMenuItem = wcomponents.SideMenuItem(_("Layout"),
  87             urlHandlers.UHAdminLayoutGeneral.getURL())
  88         mainSection.addItem( self._templatesMenuItem)
  89
  90         self._servicesMenuItem = wcomponents.SideMenuItem(_("Services"), urlHandlers.UHIPBasedACL.getURL())
  91         mainSection.addItem(self._servicesMenuItem)
  92
  93         self._homepageMenuItem = wcomponents.SideMenuItem(_("Homepage"),
  94             urlHandlers.UHUpdateNews.getURL())
  95         mainSection.addItem( self._homepageMenuItem)
  96
  97         self._systemMenuItem = wcomponents.SideMenuItem(_("System"),
  98             urlHandlers.UHAdminsSystem.getURL())
  99         mainSection.addItem( self._systemMenuItem)
 100
 101         self._protectionMenuItem = wcomponents.SideMenuItem(_("Protection"),
 102             urlHandlers.UHAdminsProtection.getURL())
 103         mainSection.addItem( self._protectionMenuItem)
 104
 105         self.extra_menu_items = {}
 106         for name, item in sorted(values_from_signal(signals.admin_sidemenu.send()),
 107                                  key=lambda x: x[1]._title):
 108             self.extra_menu_items[name] = item
 109             mainSection.addItem(item)
 110
 111         self._sideMenu.addSection(mainSection)
 112
 113
 114     def _getBody( self, params ):
 115         self._createSideMenu()
 116         self._setActiveSideMenuItem()
 117
 118         self._createTabCtrl()
 119         self._setActiveTab()
 120
 121         frame = WAdminFrame()
 122         p = { "body": self._getPageContent( params ),
 123               "sideMenu": self._sideMenu.getHTML() }
 124
 125         return frame.getHTML( p )
 126
 127     def _getNavigationDrawer(self):
 128         return wcomponents.WSimpleNavigationDrawer(_("Server Admin"), urlHandlers.UHAdminArea.getURL, bgColor="white" )
 129
 130     def _createTabCtrl(self):
 131         pass
 132
 133     def _getTabContent(self):
 134         return "nothing"
 135
 136     def _setActiveTab(self):
 137         pass
 138
 139     def _setActiveSideMenuItem(self):
 140         pass
 141
 142     def _getPageContent(self, params):
 143         return "nothing"
 144
 145 class WAdmins(wcomponents.WTemplated):
 146
 147     def getVars( self ):
 148         vars = wcomponents.WTemplated.getVars( self )
 149         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 150         vars["title"] = minfo.getTitle()
 151         vars["organisation"] = minfo.getOrganisation()
 152         vars['supportEmail'] = Config.getInstance().getSupportEmail()
 153         vars['publicSupportEmail'] = Config.getInstance().getPublicSupportEmail()
 154         vars['noReplyEmail'] = Config.getInstance().getNoReplyEmail()
 155         vars["lang"] = minfo.getLang()
 156         vars["address"] = ""
 157         if minfo.getCity() != "":
 158             vars["address"] = minfo.getCity()
 159         if minfo.getCountry() != "":
 160             if vars["address"] != "":
 161                 vars["address"] = "%s (%s)"%(vars["address"], minfo.getCountry())
 162             else:
 163                 vars["address"] = "%s"%minfo.getCountry()
 164         vars["timezone"] = Config.getInstance().getDefaultTimezone()
 165         vars["systemIconAdmins"] = Config.getInstance().getSystemIconURL( "admin" )
 166         iconDisabled = str(Config.getInstance().getSystemIconURL( "disabledSection" ))
 167         iconEnabled = str(Config.getInstance().getSystemIconURL( "enabledSection" ))
 168         url = urlHandlers.UHAdminSwitchNewsActive.getURL()
 169         icon = iconEnabled if minfo.isNewsActive() else iconDisabled
 170         vars["features"] = i18nformat("""<a href="%s"><img src="%s" border="0" style="float:left; padding-right: 5px">_("News Pages")</a>""") % (url, icon)
 171         vars["administrators"] = fossilize(sorted([u.as_avatar for u in User.find(is_admin=True, is_deleted=False)],
 172                                                   key=methodcaller('getStraightFullName')))
 173         return vars
 174
 175
 176 class WAdminFrame(wcomponents.WTemplated):
 177
 178     def __init__( self ):
 179         pass
 180
 181     def getVars( self ):
 182         vars = wcomponents.WTemplated.getVars( self )
 183         vars["imgGestionGrey"] = Config.getInstance().getSystemIconURL( "gestionGrey" )
 184         vars["titleTabPixels"] = self.getTitleTabPixels()
 185         vars["intermediateVTabPixels"] = self.getIntermediateVTabPixels()
 186         return vars
 187
 188     def getIntermediateVTabPixels( self ):
 189         return 0
 190
 191     def getTitleTabPixels( self ):
 192         return 260
 193
 194
 195 class WPAdmins( WPAdminsBase ):
 196
 197     def _setActiveSideMenuItem(self):
 198         self._generalSettingsMenuItem.setActive()
 199
 200     def _getPageContent( self, params ):
 201         wc = WAdmins()
 202         pars = { "GeneralInfoModifURL": urlHandlers.UHGeneralInfoModification.getURL() }
 203         return wc.getHTML( pars )
 204
 205
 206 class WGeneralInfoModification(wcomponents.WTemplated):
 207
 208     def getVars(self):
 209         vars = wcomponents.WTemplated.getVars(self)
 210         genInfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 211         vars["title"] = genInfo.getTitle()
 212         vars["organisation"] = genInfo.getOrganisation()
 213         vars["city"] = genInfo.getCity()
 214         vars["country"] = genInfo.getCountry()
 215         vars["language"] = genInfo.getLang()
 216         vars["language_list"] = get_all_locales()
 217         return vars
 218
 219
 220 class WPGenInfoModification( WPAdmins ):
 221
 222     def _getPageContent( self, params ):
 223         wc = WGeneralInfoModification()
 224         pars = { "postURL": urlHandlers.UHGeneralInfoPerformModification.getURL() }
 225         return wc.getHTML( pars )
 226
 227 class WPHomepageCommon( WPAdminsBase ):
 228     def _setActiveSideMenuItem(self):
 229         self._homepageMenuItem.setActive()
 230
 231     def _createTabCtrl( self ):
 232         self._tabCtrl = wcomponents.TabControl()
 233
 234         self._subTabNews = self._tabCtrl.newTab( "news", _("News"), \
 235                 urlHandlers.UHUpdateNews.getURL() )
 236         self._subTabAnnouncements = self._tabCtrl.newTab( "announcements", _("Announcements"), \
 237                 urlHandlers.UHAnnouncement.getURL() )
 238         self._subTabUpcoming = self._tabCtrl.newTab( "upcoming", _("Upcoming Events"), \
 239                 urlHandlers.UHConfigUpcomingEvents.getURL() )
 240
 241     def _getPageContent(self, params):
 242         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 243
 244 class WPUpdateNews( WPHomepageCommon ):
 245
 246     def _setActiveTab( self ):
 247         self._subTabNews.setActive()
 248
 249     def getCSSFiles(self):
 250         return WPHomepageCommon.getCSSFiles(self) + self._asset_env['news_sass'].urls()
 251
 252     def _getTabContent( self, params ):
 253         tz = timezone(timezoneUtils.DisplayTZ(self._getAW()).getDisplayTZ())
 254         wc = WUpdateNews()
 255         newsModule = ModuleHolder().getById("news")
 256
 257         newslist = fossilize(newsModule.getNewsItemsList(), INewsItemFossil, tz=tz)
 258         newsTypesList = newsModule.getNewsTypesAsDict()
 259         recentDays = newsModule.getRecentDays()
 260
 261         pars = {"newslist": newslist,
 262                 "newsTypesList": newsTypesList,
 263                 "recentDays": recentDays }
 264
 265         return wc.getHTML( pars )
 266
 267 class WUpdateNews(wcomponents.WTemplated):
 268
 269     def getVars( self ):
 270         vars = wcomponents.WTemplated.getVars( self )
 271         vars["baseURL"] = Config.getInstance().getBaseURL()
 272         vars["postURL"] = urlHandlers.UHUpdateNews.getURL()
 273         return vars
 274
 275 class WPConfigUpcomingEvents( WPHomepageCommon ):
 276
 277     def _setActiveTab( self ):
 278         self._subTabUpcoming.setActive()
 279
 280     def _getTabContent( self, params ):
 281         wc = WConfigUpcomingEvents()
 282         pars = {}
 283         return wc.getHTML( pars )
 284
 285 class WConfigUpcomingEvents(wcomponents.WTemplated):
 286
 287     def getVars( self ):
 288         vars = wcomponents.WTemplated.getVars( self )
 289         module = ModuleHolder().getById("upcoming_events")
 290         vars["cacheTTL"] = module.getCacheTTL().seconds/60
 291         vars["numberItems"] = module.getNumberItems()
 292         return vars
 293
 294
 295 class WPAnnouncementModif( WPHomepageCommon ):
 296
 297     def _setActiveTab( self ):
 298         self._subTabAnnouncements.setActive()
 299
 300     def _getTabContent( self, params ):
 301         wc = WAnnouncementModif()
 302         pars = {"saveURL": urlHandlers.UHAnnouncementSave.getURL() }
 303         return wc.getHTML( pars )
 304
 305 class WAnnouncementModif(wcomponents.WTemplated):
 306
 307     def getVars(self):
 308         vars = wcomponents.WTemplated.getVars(self)
 309         an = getAnnoucementMgrInstance()
 310         vars["announcement"] = escape(an.getText()).replace("\"", "&#34;")
 311         return vars
 312
 313
 314 class WPServicesCommon( WPAdminsBase ):
 315
 316     def _setActiveSideMenuItem(self):
 317         self._servicesMenuItem.setActive()
 318
 319     def _createTabCtrl( self ):
 320         self._tabCtrl = wcomponents.TabControl()
 321
 322         self._subTabIPBasedACL = self._tabCtrl.newTab( "ip_based_acl", _("IP Based ACL"), \
 323                 urlHandlers.UHIPBasedACL.getURL() )
 324
 325     def _getPageContent(self, params):
 326         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 327
 328
 329 class WPTemplatesCommon( WPAdminsBase ):
 330
 331     def _setActiveSideMenuItem(self):
 332         self._templatesMenuItem.setActive()
 333
 334     def _createTabCtrl( self ):
 335         self._tabCtrl = wcomponents.TabControl()
 336
 337         self._subTabGeneral = self._tabCtrl.newTab( "general", _("General Definitions"), \
 338                 urlHandlers.UHAdminLayoutGeneral.getURL() )
 339         self._subTabStyles = self._tabCtrl.newTab( "styles", _("Timetable Styles"), \
 340                 urlHandlers.UHAdminsStyles.getURL() )
 341         self._subTabCSSTpls = self._tabCtrl.newTab( "styles", _("Conference Styles"), \
 342                 urlHandlers.UHAdminsConferenceStyles.getURL() )
 343         self._subTabBadges = self._tabCtrl.newTab( "badges", _("Badges"), \
 344                 urlHandlers.UHBadgeTemplates.getURL() )
 345         self._subTabPosters = self._tabCtrl.newTab( "posters", _("Posters"), \
 346                 urlHandlers.UHPosterTemplates.getURL() )
 347
 348     def _getPageContent(self, params):
 349         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 350         if self._showAdmin:
 351             return WPAdminsBase._getBody( self, params )
 352         else:
 353             return self._getTabContent( params )
 354
 355
 356 class WPBadgeTemplatesBase(WPTemplatesCommon):
 357
 358     def getCSSFiles(self):
 359         return WPTemplatesCommon.getCSSFiles(self) + self._asset_env['indico_badges_css'].urls()
 360
 361     def getJSFiles(self):
 362         return WPTemplatesCommon.getJSFiles(self) + self._includeJSPackage('badges_js')
 363
 364
 365 class WPAdminLayoutGeneral( WPTemplatesCommon ):
 366
 367     def _setActiveTab( self ):
 368         self._subTabGeneral.setActive()
 369
 370     def __getAvailableTemplates(self):
 371         tplDir = Config.getInstance().getTPLDir()
 372
 373         tplRE = re.compile('^([^\.]+)\.([^\.]+)\.tpl$')
 374
 375         templates = {}
 376
 377         fnames = os.listdir(tplDir);
 378         for fname in fnames:
 379             m = tplRE.match(fname)
 380             if m:
 381                 templates[m.group(2)] = None
 382
 383         tplRE = re.compile('^([^\.]+)\.([^\.]+)\.wohl$')
 384
 385         fnames = os.listdir(os.path.join(tplDir, 'chelp'))
 386         for fname in fnames:
 387             m = tplRE.match(fname)
 388             if m:
 389                 templates[m.group(2)] = None
 390
 391         cssRE = re.compile('Default.([^\.]+)\.css$')
 392
 393         fnames = os.listdir(Config.getInstance().getCssDir())
 394         for fname in fnames:
 395             m = cssRE.match(fname)
 396             if m:
 397                 templates[m.group(1)] = None
 398
 399         return templates.keys()
 400
 401     def _getTabContent(self, params):
 402         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 403         socialCfg = minfo.getSocialAppConfig()
 404         wc = WAdminLayoutGeneral()
 405         pars = {
 406             "defaultTemplateSet": minfo.getDefaultTemplateSet(),
 407             "availableTemplates": self.__getAvailableTemplates(),
 408             "templateSetFormURL": urlHandlers.UHAdminLayoutSaveTemplateSet.getURL(),
 409             "socialFormURL": urlHandlers.UHAdminLayoutSaveSocial.getURL(),
 410             "socialActive": socialCfg.get('active', True),
 411             "facebookData": socialCfg.get('facebook', {})
 412         }
 413         return wc.getHTML(pars)
 414
 415
 416 class WAdminLayoutGeneral(wcomponents.WTemplated):
 417     pass
 418
 419
 420 class WPAdminsConferenceStyles( WPTemplatesCommon ):
 421
 422     def _getTabContent( self, params ):
 423         wp = WAdminsConferenceStyles()
 424         return wp.getHTML(params)
 425
 426     def _setActiveTab( self ):
 427         self._subTabCSSTpls.setActive()
 428
 429
 430 class WAdminsConferenceStyles(wcomponents.WTemplated):
 431
 432     def getVars( self ):
 433         vars = wcomponents.WTemplated.getVars( self )
 434         vars["contextHelpText"] = _("This is the list of templates that an organizer can use to customize a conference")
 435         cssTplsModule=ModuleHolder().getById("cssTpls")
 436         vars["cssTplsModule"] = cssTplsModule
 437         return vars
 438
 439
 440 class WPAdminsStyles( WPTemplatesCommon ):
 441
 442     def _getTabContent( self, params ):
 443         wp = WAdminsStyles()
 444         return wp.getHTML(params)
 445
 446     def _setActiveTab( self ):
 447         self._subTabStyles.setActive()
 448
 449 class WAdminsStyles(wcomponents.WTemplated):
 450
 451     def getVars( self ):
 452         vars = wcomponents.WTemplated.getVars( self )
 453         styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
 454         vars["styleMgr"] = styleMgr
 455         baseTPLPath = styleMgr.getBaseTPLPath()
 456         baseCSSPath = styleMgr.getBaseCSSPath()
 457         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)
 458         vars["deleteIconURL"] = Config.getInstance().getSystemIconURL("remove")
 459         return vars
 460
 461 class WPAdminsAddStyle( WPAdminsStyles ):
 462
 463     def _getTabContent( self, params ):
 464         wp = WAdminsAddStyle()
 465         return wp.getHTML(params)
 466
 467 class WAdminsAddStyle(wcomponents.WTemplated):
 468
 469     def _getAllFiles(self, basePath, extension, excludedDirs=[]):
 470         collectedFiles = []
 471         for root, dirs, files in os.walk(basePath):
 472             for excluded in excludedDirs:
 473                 if excluded in dirs:
 474                     dirs.remove(excluded)
 475             for filename in files:
 476                 fullPath = os.path.join(root, filename)
 477                 if os.path.isfile(fullPath) and filename.endswith(extension):
 478                     collectedFiles.append(os.path.relpath(fullPath, basePath))
 479         return sorted(collectedFiles)
 480
 481     def getVars( self ):
 482         vars = wcomponents.WTemplated.getVars( self )
 483         styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
 484         vars["styleMgr"] = styleMgr
 485         baseTPLPath = styleMgr.getBaseTPLPath()
 486         baseCSSPath = styleMgr.getBaseCSSPath()
 487         baseXSLPath = styleMgr.getBaseXSLPath()
 488         vars["availableTemplates"] = self._getAllFiles(baseTPLPath, '.tpl', excludedDirs=['include'])
 489         vars["availableStyleSheets"] = self._getAllFiles(baseXSLPath, '.xsl', excludedDirs=['include'])
 490         vars["availableCSS"] = self._getAllFiles(baseCSSPath, '.css')
 491         vars["xslContextHelpText"] = r"Lists all XSL files in %s (except special folders named \'include\', which are reserved)" % baseXSLPath
 492         vars["tplContextHelpText"] = r"Lists all TPL files in %s (except special folders named \'include\', which are reserved)" % baseTPLPath
 493         vars["cssContextHelpText"] = "Lists all CSS files in %s" % baseCSSPath
 494         return vars
 495
 496
 497 class WPBadgeTemplates(WPBadgeTemplatesBase):
 498     pageURL = "badgeTemplates.py"
 499
 500     def __init__(self, rh):
 501         WPBadgeTemplatesBase.__init__(self, rh)
 502
 503     def _getTabContent( self, params ):
 504         wp = WBadgeTemplates(conference.CategoryManager().getDefaultConference())
 505         return wp.getHTML(params)
 506
 507     def _setActiveTab( self ):
 508         self._subTabBadges.setActive()
 509
 510
 511 class WPPosterTemplates(WPBadgeTemplatesBase):
 512     pageURL = "posterTemplates.py"
 513
 514     def __init__(self, rh):
 515         WPBadgeTemplatesBase.__init__(self, rh)
 516
 517     def _getTabContent( self, params ):
 518         wp = WPosterTemplates(conference.CategoryManager().getDefaultConference())
 519         return wp.getHTML(params)
 520
 521     def _setActiveTab(self):
 522         self._subTabPosters.setActive()
 523
 524
 525 class WPBadgeTemplateDesign(WPBadgeTemplatesBase):
 526
 527     def __init__(self, rh, conf, templateId=None, new=False):
 528         WPBadgeTemplatesBase.__init__(self, rh)
 529         self._conf = conf
 530         self.__templateId = templateId
 531         self.__new = new
 532
 533     def _setActiveTab(self):
 534         self._subTabBadges.setActive()
 535
 536     def _getTabContent(self, params):
 537         wc = conferences.WConfModifBadgeDesign(self._conf, self.__templateId, self.__new)
 538         return wc.getHTML()
 539
 540
 541 class WPPosterTemplateDesign(WPBadgeTemplatesBase):
 542
 543     def __init__(self, rh, conf, templateId=None, new=False):
 544         WPBadgeTemplatesBase.__init__(self, rh)
 545         self._conf = conf
 546         self.__templateId = templateId
 547         self.__new = new
 548
 549     def _setActiveTab(self):
 550         self._subTabPosters.setActive()
 551
 552     def _getTabContent(self, params):
 553         wc = conferences.WConfModifPosterDesign(self._conf, self.__templateId, self.__new)
 554         return wc.getHTML()
 555
 556
 557 class WBadgePosterTemplatingBase(wcomponents.WTemplated):
 558
 559     DEF_TEMPLATE_BADGE = None
 560
 561     def __init__(self, conference, user=None):
 562         wcomponents.WTemplated.__init__(self)
 563         self._conf = conference
 564         self._user = user
 565
 566     def getVars(self):
 567         uh = urlHandlers
 568         vars = wcomponents.WTemplated.getVars(self)
 569         vars['NewDefaultTemplateURL'] = str(self.DEF_TEMPLATE_BADGE.getURL(self._conf,
 570                                                                              self._conf.getBadgeTemplateManager().getNewTemplateId(), new=True))
 571
 572         vars['templateList'] = self._getTemplates()
 573         self._addExtras(vars)
 574
 575         return vars
 576
 577     def _getConfTemplates(self):
 578         """
 579         To be overridden in inheriting class.
 580         """
 581         pass
 582
 583     def _getTemplates(self):
 584         templates = []
 585         rawTemplates = self._getConfTemplates()
 586         rawTemplates.sort(lambda x, y: cmp(x[1].getName(), y[1].getName()))
 587
 588         for templateId, template in rawTemplates:
 589             templates.append(self._processTemplate(templateId, template))
 590
 591         return templates
 592
 593     def _addExtras(self, vars):
 594         """
 595         To be overridden in inheriting class, adds specific entries
 596         into the dictionary vars which the child implementation may require.
 597         """
 598         pass
 599
 600     def _processTemplate(self, templateId, template):
 601         """
 602         To be overridden in inheriting class, takes the template and its
 603         ID, the child then processes the data into the format it expects later.
 604         """
 605         pass
 606
 607
 608 class WBadgeTemplates(WBadgePosterTemplatingBase):
 609
 610     DEF_TEMPLATE_BADGE = urlHandlers.UHModifDefTemplateBadge
 611
 612     def _addExtras(self, vars):
 613         vars['PDFOptions'] = WConfModifBadgePDFOptions(self._conf,
 614                                                        showKeepValues=False,
 615                                                        showTip=False).getHTML()
 616
 617     def _getConfTemplates(self):
 618         return self._conf.getBadgeTemplateManager().getTemplates().items()
 619
 620     def _processTemplate(self, templateId, template):
 621         uh = urlHandlers
 622
 623         data = {
 624             'name': template.getName(),
 625             'urlEdit': str(uh.UHConfModifBadgeDesign.getURL(self._conf, templateId)),
 626             'urlDelete': str(uh.UHConfModifBadgePrinting.getURL(self._conf, deleteTemplateId=templateId))
 627         }
 628
 629         return data
 630
 631
 632 class WPosterTemplates(WBadgePosterTemplatingBase):
 633
 634     DEF_TEMPLATE_BADGE = urlHandlers.UHModifDefTemplatePoster
 635
 636     def _getConfTemplates(self):
 637         return self._conf.getPosterTemplateManager().getTemplates().items()
 638
 639     def _processTemplate(self, templateId, template):
 640         uh = urlHandlers
 641
 642         data = {
 643             'name': template.getName(),
 644             'urlEdit': str(uh.UHConfModifPosterDesign.getURL(self._conf, templateId)),
 645             'urlDelete': str(uh.UHConfModifPosterPrinting.getURL(self._conf, deleteTemplateId=templateId)),
 646             'urlCopy': str(uh.UHConfModifPosterPrinting.getURL(self._conf, copyTemplateId=templateId))
 647         }
 648
 649         return data
 650
 651
 652 class WPDomainBase( WPAdminsBase ):
 653
 654     def __init__( self, rh ):
 655         WPAdminsBase.__init__( self, rh )
 656
 657     def _setActiveSideMenuItem( self ):
 658         self._domainsMenuItem.setActive()
 659
 660 class WBrowseDomains( wcomponents.WTemplated ):
 661
 662     def __init__( self, letter=None ):
 663         self._letter = letter
 664
 665     def getVars( self ):
 666         vars = wcomponents.WTemplated.getVars( self )
 667         dh = domain.DomainHolder()
 668         letters = dh.getBrowseIndex()
 669         vars["browseIndex"] = i18nformat("""
 670         <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.disable=1;document.browseForm.submit();return false;">_("clear")</a></span>""")
 671         if self._letter == "all":
 672             vars["browseIndex"] += """
 673         [all] """
 674         else:
 675             vars["browseIndex"] += i18nformat("""
 676         <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='all';document.browseForm.submit();return false;">_("all")</a></span> """)
 677         for letter in letters:
 678             if self._letter == letter:
 679                 vars["browseIndex"] += """\n[%s] """ % letter
 680             else:
 681                 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)
 682         vars["browseResult"] = ""
 683         if self._letter not in [ None, "" ]:
 684             if self._letter != "all":
 685                 res = dh.matchFirstLetter(self._letter)
 686             else:
 687                 res = dh.getValuesToList()
 688             res.sort(key=lambda x: x.getName().lower())
 689             vars["browseResult"] = WHTMLDomainList(vars,res).getHTML()
 690         return vars
 691
 692 class WDomainList(wcomponents.WTemplated):
 693
 694     def __init__( self, criteria, params ):
 695         self._criteria = criteria
 696         self._params = params
 697
 698     def _performSearch( self, criteria ):
 699         dh = domain.DomainHolder()
 700         res = dh.match(criteria)
 701         return res
 702
 703     def getVars( self ):
 704         vars = wcomponents.WTemplated.getVars( self )
 705         vars["createDomainURL"] = urlHandlers.UHNewDomain.getURL()
 706         vars["nbDomains"] = domain.DomainHolder().getLength()
 707         vars["browseDomains"] = WBrowseDomains(self._params.get("letter",None)).getHTML(vars)
 708         vars["browseDomainsURL"] = urlHandlers.UHDomains.getURL()
 709         vars["searchDomainsURL"] = urlHandlers.UHDomains.getURL()
 710         vars["domains"] = ""
 711         if self._criteria:
 712             domainList = self._performSearch(self._criteria)
 713             vars["domains"] = WHTMLDomainList(vars,domainList).getHTML()
 714         return vars
 715
 716 class WHTMLDomainList:
 717
 718     def __init__(self, vars, list):
 719         self._vars = vars
 720         self._list = list
 721
 722     def getHTML(self):
 723         text = """<tr>
 724                               <td>
 725                     <br>
 726                 <table width="100%%" align="left" style="border-top: 1px solid #777777; padding-top:10px">"""
 727         color="white"
 728         ul = []
 729         for dom in self._list:
 730             if color=="white":
 731                 color="#F6F6F6"
 732             else:
 733                 color="white"
 734             url = self._vars["domainDetailsURLGen"]( dom )
 735             ul.append("""<tr>
 736                             <td bgcolor="%s"><a href="%s">%s</a></td>
 737                         </tr>"""%(color, url, dom.getName() or _("no name") ) )
 738         if ul:
 739             text += "".join( ul )
 740         else:
 741             text += """<tr>
 742                         <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp;No domains for this search</span></td></tr>"""
 743         text += """    </table>
 744                       </td>
 745                 </tr>"""
 746         return text
 747
 748 class WPDomainList( WPDomainBase ):
 749
 750     def __init__( self, rh, params ):
 751         WPDomainBase.__init__( self, rh )
 752         self._params = params
 753
 754     def _getPageContent( self, params ):
 755         criteria = {}
 756         if self._params.get("sName","") != "":
 757             criteria["name"] = self._params.get("sName","")
 758         comp = WDomainList(criteria,self._params)
 759         pars = {"domainDetailsURLGen": urlHandlers.UHDomainDetails.getURL }
 760         return comp.getHTML(pars)
 761
 762
 763 class WDomainDetails(wcomponents.WTemplated):
 764
 765     def __init__( self, dom):
 766         self._domain = dom
 767
 768     def getVars( self ):
 769         vars = wcomponents.WTemplated.getVars( self )
 770         vars["name"] = self._domain.getName()
 771         vars["description"] = self._domain.getDescription()
 772         vars["filters"] = "<br>".join(self._domain.getFilterList())
 773         return vars
 774
 775
 776 class WPDomainDetails( WPDomainBase ):
 777
 778     def __init__(self, rh, domain):
 779         WPDomainBase.__init__(self, rh)
 780         self._domain = domain
 781
 782     def _getPageContent( self, params ):
 783         comp = WDomainDetails( self._domain )
 784         pars = {"modifyURL": urlHandlers.UHDomainModification.getURL( self._domain ) }
 785         return comp.getHTML( pars )
 786
 787
 788 class WDomainDataModification(wcomponents.WTemplated):
 789
 790     def __init__( self, dom ):
 791         self._domain = dom
 792
 793     def getVars( self ):
 794         vars = wcomponents.WTemplated.getVars( self )
 795         vars["name"] = self._domain.getName()
 796         vars["description"] = self._domain.getDescription()
 797         vars["filters"] = ";".join( self._domain.getFilterList() )
 798         vars["locator"] = self._domain.getLocator().getWebForm()
 799         return vars
 800
 801
 802 class WPDomainModification( WPDomainBase ):
 803
 804     def __init__(self, rh, domain):
 805         WPDomainBase.__init__(self, rh)
 806         self._domain = domain
 807
 808     def _getPageContent( self, params ):
 809         comp = WDomainDataModification( self._domain )
 810         pars = {
 811             'postURL': urlHandlers.UHDomainPerformModification.getURL(self._domain)
 812         }
 813         return comp.getHTML( pars )
 814
 815
 816 class WDomainCreation(wcomponents.WTemplated):
 817     pass
 818
 819
 820 class WPDomainCreation( WPDomainBase ):
 821
 822     def _getPageContent( self, params ):
 823         comp = WDomainCreation()
 824         pars = {"postURL": urlHandlers.UHDomainPerformCreation.getURL()}
 825         return comp.getHTML( pars )
 826
 827
 828 class WPAdminsSystemBase(WPAdminsBase):
 829     def __init__(self, rh):
 830         WPAdminsBase.__init__(self, rh)
 831
 832     def _setActiveSideMenuItem(self):
 833         self._systemMenuItem.setActive()
 834
 835     def _createTabCtrl(self):
 836         self._tabCtrl = wcomponents.TabControl()
 837
 838         self._subTabConfiguration = self._tabCtrl.newTab("configuration", _("Configuration"),
 839                                                          urlHandlers.UHAdminsSystem.getURL())
 840         self._subTabMaintenance = self._tabCtrl.newTab("maintenance", _("Maintenance"),
 841                                                        urlHandlers.UHMaintenance.getURL())
 842
 843     def _getPageContent(self, params):
 844         return wcomponents.WTabControl(self._tabCtrl, self._getAW()).getHTML(self._getTabContent(params))
 845
 846
 847 class WPAdminsSystem(WPAdminsSystemBase):
 848
 849     def _setActiveTab(self):
 850         self._subTabConfiguration.setActive()
 851
 852     def _getTabContent(self, params):
 853         wc = WAdminsSystem()
 854         return wc.getHTML(params)
 855
 856
 857 class WAdminsSystem(wcomponents.WTemplated):
 858
 859     def getVars(self):
 860         vars = wcomponents.WTemplated.getVars(self)
 861         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 862         vars["minfo"] = minfo
 863         vars["ModifURL"] = urlHandlers.UHAdminsSystemModif.getURL()
 864         vars['use_proxy'] = Config.getInstance().getUseProxy()
 865         return vars
 866
 867
 868 class WPAdminsSystemModif(WPAdminsSystemBase):
 869
 870     def _getTabContent(self, params):
 871         wc = WAdminsSystemModif()
 872         return wc.getHTML(params)
 873
 874
 875 class WAdminsSystemModif(wcomponents.WTemplated):
 876
 877     def getVars(self):
 878         vars = wcomponents.WTemplated.getVars(self)
 879         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 880         vars["minfo"] = minfo
 881         vars["postURL"] = urlHandlers.UHAdminsSystemModif.getURL()
 882         return vars
 883
 884
 885 class WPMaintenanceBase(WPAdminsSystemBase):
 886
 887     def __init__(self, rh):
 888         WPAdminsBase.__init__(self, rh)
 889
 890     def _setActiveTab(self):
 891         self._subTabMaintenance.setActive()
 892
 893
 894 class WPMaintenance(WPMaintenanceBase):
 895
 896     def __init__(self, rh, s, dbSize):
 897         WPMaintenanceBase.__init__(self, rh)
 898         self._stat = s
 899         self._dbSize = dbSize
 900
 901     def _getTabContent(self, params):
 902         wc = WAdminMaintenance()
 903         pars = { "cleanupURL": urlHandlers.UHMaintenanceTmpCleanup.getURL(), \
 904                  "tempSize": self._stat[0], \
 905                  "nFiles": "%s files" % self._stat[1], \
 906                  "nDirs": "%s folders" % self._stat[2], \
 907                  "packURL": urlHandlers.UHMaintenancePack.getURL(), \
 908                  "dbSize": self._dbSize}
 909         return wc.getHTML(pars)
 910
 911
 912 class WAdminMaintenance(wcomponents.WTemplated):
 913
 914     def getVars(self):
 915         vars = wcomponents.WTemplated.getVars(self)
 916         return vars
 917
 918
 919 class WPMaintenanceTmpCleanup(WPMaintenanceBase):
 920
 921     def __init__(self, rh):
 922         WPMaintenanceBase.__init__(self, rh)
 923
 924     def _getTabContent(self, params):
 925         msg = """Are you sure you want to delete the temporary directory
 926         (note that all the files in that directory will be deleted)?"""
 927         wc = wcomponents.WConfirmation()
 928         url = urlHandlers.UHMaintenancePerformTmpCleanup.getURL()
 929         return """
 930                 <table align="center" width="95%%">
 931                     <tr>
 932                         <td class="formTitle">Maintenance: Cleaning-up temporary directory</td>
 933                     </tr>
 934                     <tr>
 935                         <td>
 936                     <br>
 937                             %s
 938                         </td>
 939                     </tr>
 940                 </table>
 941                 """ % wc.getHTML(msg, url, {})
 942
 943
 944 class WPMaintenancePack(WPMaintenanceBase):
 945
 946     def __init__(self, rh):
 947         WPMaintenanceBase.__init__(self, rh)
 948
 949     def _getTabContent(self, params):
 950         wc = wcomponents.WConfirmation()
 951         msg = """Are you sure you want to pack the database?"""
 952         url = urlHandlers.UHMaintenancePerformPack.getURL()
 953         return """
 954                 <table align="center" width="95%%">
 955                     <tr>
 956                         <td class="formTitle">Maintenance: Database packing</td>
 957                     </tr>
 958                     <tr>
 959                         <td>
 960                     <br>
 961                             %s
 962                         </td>
 963                     </tr>
 964                 </table>
 965                 """ % wc.getHTML(msg, url, {})
 966
 967
 968 class WPIPBasedACL( WPServicesCommon ):
 969
 970     def __init__( self, rh ):
 971         WPServicesCommon.__init__( self, rh )
 972
 973     def _getTabContent(self, params):
 974         wc = WIPBasedACL()
 975         return wc.getHTML(params)
 976
 977     def _setActiveTab(self):
 978         self._subTabIPBasedACL.setActive()
 979
 980
 981 class WIPBasedACL(wcomponents.WTemplated):
 982
 983     def getVars(self):
 984         vars = wcomponents.WTemplated.getVars(self)
 985         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 986         vars["ipList"] = minfo.getIPBasedACLMgr().get_full_access_acl()
 987         vars["removeIcon"] = Config.getInstance().getSystemIconURL("remove")
 988         return vars
 989
 990
 991 class WPAdminProtection(WPAdminsBase):
 992
 993     def _setActiveSideMenuItem(self):
 994         self._protectionMenuItem.setActive()
 995
 996     def _getPageContent(self, params):
 997         wc = WAdminProtection()
 998         return wc.getHTML()
 999
1000
1001 class WAdminProtection(wcomponents.WTemplated):
1002
1003     def getVars(self):
1004         vars = wcomponents.WTemplated.getVars(self)
1005         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1006         vars["protectionDisclaimerProtected"] = minfo.getProtectionDisclaimerProtected()
1007         vars["protectionDisclaimerRestricted"] = minfo.getProtectionDisclaimerRestricted()
1008         return vars