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 class WRBAdminFrame(WAdminFrame):
 195     pass
 196
 197 class WPAdmins( WPAdminsBase ):
 198
 199     def _setActiveSideMenuItem(self):
 200         self._generalSettingsMenuItem.setActive()
 201
 202     def _getPageContent( self, params ):
 203         wc = WAdmins()
 204         pars = { "GeneralInfoModifURL": urlHandlers.UHGeneralInfoModification.getURL() }
 205         return wc.getHTML( pars )
 206
 207
 208 class WGeneralInfoModification(wcomponents.WTemplated):
 209
 210     def getVars(self):
 211         vars = wcomponents.WTemplated.getVars(self)
 212         genInfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 213         vars["title"] = genInfo.getTitle()
 214         vars["organisation"] = genInfo.getOrganisation()
 215         vars["city"] = genInfo.getCity()
 216         vars["country"] = genInfo.getCountry()
 217         vars["language"] = genInfo.getLang()
 218         vars["language_list"] = get_all_locales()
 219         return vars
 220
 221
 222 class WPGenInfoModification( WPAdmins ):
 223
 224     def _getPageContent( self, params ):
 225         wc = WGeneralInfoModification()
 226         pars = { "postURL": urlHandlers.UHGeneralInfoPerformModification.getURL() }
 227         return wc.getHTML( pars )
 228
 229 class WPHomepageCommon( WPAdminsBase ):
 230     def _setActiveSideMenuItem(self):
 231         self._homepageMenuItem.setActive()
 232
 233     def _createTabCtrl( self ):
 234         self._tabCtrl = wcomponents.TabControl()
 235
 236         self._subTabNews = self._tabCtrl.newTab( "news", _("News"), \
 237                 urlHandlers.UHUpdateNews.getURL() )
 238         self._subTabAnnouncements = self._tabCtrl.newTab( "announcements", _("Announcements"), \
 239                 urlHandlers.UHAnnouncement.getURL() )
 240         self._subTabUpcoming = self._tabCtrl.newTab( "upcoming", _("Upcoming Events"), \
 241                 urlHandlers.UHConfigUpcomingEvents.getURL() )
 242
 243     def _getPageContent(self, params):
 244         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 245
 246 class WPUpdateNews( WPHomepageCommon ):
 247
 248     def _setActiveTab( self ):
 249         self._subTabNews.setActive()
 250
 251     def getCSSFiles(self):
 252         return WPHomepageCommon.getCSSFiles(self) + self._asset_env['news_sass'].urls()
 253
 254     def _getTabContent( self, params ):
 255         tz = timezone(timezoneUtils.DisplayTZ(self._getAW()).getDisplayTZ())
 256         wc = WUpdateNews()
 257         newsModule = ModuleHolder().getById("news")
 258
 259         newslist = fossilize(newsModule.getNewsItemsList(), INewsItemFossil, tz=tz)
 260         newsTypesList = newsModule.getNewsTypesAsDict()
 261         recentDays = newsModule.getRecentDays()
 262
 263         pars = {"newslist": newslist,
 264                 "newsTypesList": newsTypesList,
 265                 "recentDays": recentDays }
 266
 267         return wc.getHTML( pars )
 268
 269 class WUpdateNews(wcomponents.WTemplated):
 270
 271     def getVars( self ):
 272         vars = wcomponents.WTemplated.getVars( self )
 273         vars["baseURL"] = Config.getInstance().getBaseURL()
 274         vars["postURL"] = urlHandlers.UHUpdateNews.getURL()
 275         return vars
 276
 277 class WPConfigUpcomingEvents( WPHomepageCommon ):
 278
 279     def _setActiveTab( self ):
 280         self._subTabUpcoming.setActive()
 281
 282     def _getTabContent( self, params ):
 283         wc = WConfigUpcomingEvents()
 284         pars = {}
 285         return wc.getHTML( pars )
 286
 287 class WConfigUpcomingEvents(wcomponents.WTemplated):
 288
 289     def getVars( self ):
 290         vars = wcomponents.WTemplated.getVars( self )
 291         module = ModuleHolder().getById("upcoming_events")
 292         vars["cacheTTL"] = module.getCacheTTL().seconds/60
 293         vars["numberItems"] = module.getNumberItems()
 294         return vars
 295
 296
 297 class WPAnnouncementModif( WPHomepageCommon ):
 298
 299     def _setActiveTab( self ):
 300         self._subTabAnnouncements.setActive()
 301
 302     def _getTabContent( self, params ):
 303         wc = WAnnouncementModif()
 304         pars = {"saveURL": urlHandlers.UHAnnouncementSave.getURL() }
 305         return wc.getHTML( pars )
 306
 307 class WAnnouncementModif(wcomponents.WTemplated):
 308
 309     def getVars(self):
 310         vars = wcomponents.WTemplated.getVars(self)
 311         an = getAnnoucementMgrInstance()
 312         vars["announcement"] = escape(an.getText()).replace("\"", "&#34;")
 313         return vars
 314
 315
 316 class WPServicesCommon( WPAdminsBase ):
 317
 318     def _setActiveSideMenuItem(self):
 319         self._servicesMenuItem.setActive()
 320
 321     def _createTabCtrl( self ):
 322         self._tabCtrl = wcomponents.TabControl()
 323
 324         self._subTabIPBasedACL = self._tabCtrl.newTab( "ip_based_acl", _("IP Based ACL"), \
 325                 urlHandlers.UHIPBasedACL.getURL() )
 326
 327     def _getPageContent(self, params):
 328         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 329
 330
 331 class WPTemplatesCommon( WPAdminsBase ):
 332
 333     def _setActiveSideMenuItem(self):
 334         self._templatesMenuItem.setActive()
 335
 336     def _createTabCtrl( self ):
 337         self._tabCtrl = wcomponents.TabControl()
 338
 339         self._subTabGeneral = self._tabCtrl.newTab( "general", _("General Definitions"), \
 340                 urlHandlers.UHAdminLayoutGeneral.getURL() )
 341         self._subTabStyles = self._tabCtrl.newTab( "styles", _("Timetable Styles"), \
 342                 urlHandlers.UHAdminsStyles.getURL() )
 343         self._subTabCSSTpls = self._tabCtrl.newTab( "styles", _("Conference Styles"), \
 344                 urlHandlers.UHAdminsConferenceStyles.getURL() )
 345         self._subTabBadges = self._tabCtrl.newTab( "badges", _("Badges"), \
 346                 urlHandlers.UHBadgeTemplates.getURL() )
 347         self._subTabPosters = self._tabCtrl.newTab( "posters", _("Posters"), \
 348                 urlHandlers.UHPosterTemplates.getURL() )
 349
 350     def _getPageContent(self, params):
 351         return wcomponents.WTabControl( self._tabCtrl, self._getAW() ).getHTML( self._getTabContent( params ) )
 352         if self._showAdmin:
 353             return WPAdminsBase._getBody( self, params )
 354         else:
 355             return self._getTabContent( params )
 356
 357
 358 class WPBadgeTemplatesBase(WPTemplatesCommon):
 359
 360     def getCSSFiles(self):
 361         return WPTemplatesCommon.getCSSFiles(self) + self._asset_env['indico_badges_css'].urls()
 362
 363     def getJSFiles(self):
 364         return WPTemplatesCommon.getJSFiles(self) + self._includeJSPackage('badges_js')
 365
 366
 367 class WPAdminLayoutGeneral( WPTemplatesCommon ):
 368
 369     def _setActiveTab( self ):
 370         self._subTabGeneral.setActive()
 371
 372     def __getAvailableTemplates(self):
 373         tplDir = Config.getInstance().getTPLDir()
 374
 375         tplRE = re.compile('^([^\.]+)\.([^\.]+)\.tpl$')
 376
 377         templates = {}
 378
 379         fnames = os.listdir(tplDir);
 380         for fname in fnames:
 381             m = tplRE.match(fname)
 382             if m:
 383                 templates[m.group(2)] = None
 384
 385         tplRE = re.compile('^([^\.]+)\.([^\.]+)\.wohl$')
 386
 387         fnames = os.listdir(os.path.join(tplDir, 'chelp'))
 388         for fname in fnames:
 389             m = tplRE.match(fname)
 390             if m:
 391                 templates[m.group(2)] = None
 392
 393         cssRE = re.compile('Default.([^\.]+)\.css$')
 394
 395         fnames = os.listdir(Config.getInstance().getCssDir())
 396         for fname in fnames:
 397             m = cssRE.match(fname)
 398             if m:
 399                 templates[m.group(1)] = None
 400
 401         return templates.keys()
 402
 403     def _getTabContent(self, params):
 404         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 405         socialCfg = minfo.getSocialAppConfig()
 406         wc = WAdminLayoutGeneral()
 407         pars = {
 408             "defaultTemplateSet": minfo.getDefaultTemplateSet(),
 409             "availableTemplates": self.__getAvailableTemplates(),
 410             "templateSetFormURL": urlHandlers.UHAdminLayoutSaveTemplateSet.getURL(),
 411             "socialFormURL": urlHandlers.UHAdminLayoutSaveSocial.getURL(),
 412             "socialActive": socialCfg.get('active', True),
 413             "facebookData": socialCfg.get('facebook', {})
 414         }
 415         return wc.getHTML(pars)
 416
 417
 418 class WAdminLayoutGeneral(wcomponents.WTemplated):
 419     pass
 420
 421
 422 class WPAdminsConferenceStyles( WPTemplatesCommon ):
 423
 424     def _getTabContent( self, params ):
 425         wp = WAdminsConferenceStyles()
 426         return wp.getHTML(params)
 427
 428     def _setActiveTab( self ):
 429         self._subTabCSSTpls.setActive()
 430
 431
 432 class WAdminsConferenceStyles(wcomponents.WTemplated):
 433
 434     def getVars( self ):
 435         vars = wcomponents.WTemplated.getVars( self )
 436         vars["contextHelpText"] = _("This is the list of templates that an organizer can use to customize a conference")
 437         cssTplsModule=ModuleHolder().getById("cssTpls")
 438         vars["cssTplsModule"] = cssTplsModule
 439         return vars
 440
 441
 442 class WPAdminsStyles( WPTemplatesCommon ):
 443
 444     def _getTabContent( self, params ):
 445         wp = WAdminsStyles()
 446         return wp.getHTML(params)
 447
 448     def _setActiveTab( self ):
 449         self._subTabStyles.setActive()
 450
 451 class WAdminsStyles(wcomponents.WTemplated):
 452
 453     def getVars( self ):
 454         vars = wcomponents.WTemplated.getVars( self )
 455         styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
 456         vars["styleMgr"] = styleMgr
 457         baseTPLPath = styleMgr.getBaseTPLPath()
 458         baseCSSPath = styleMgr.getBaseCSSPath()
 459         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)
 460         vars["deleteIconURL"] = Config.getInstance().getSystemIconURL("remove")
 461         return vars
 462
 463 class WPAdminsAddStyle( WPAdminsStyles ):
 464
 465     def _getTabContent( self, params ):
 466         wp = WAdminsAddStyle()
 467         return wp.getHTML(params)
 468
 469 class WAdminsAddStyle(wcomponents.WTemplated):
 470
 471     def _getAllFiles(self, basePath, extension, excludedDirs=[]):
 472         collectedFiles = []
 473         for root, dirs, files in os.walk(basePath):
 474             for excluded in excludedDirs:
 475                 if excluded in dirs:
 476                     dirs.remove(excluded)
 477             for filename in files:
 478                 fullPath = os.path.join(root, filename)
 479                 if os.path.isfile(fullPath) and filename.endswith(extension):
 480                     collectedFiles.append(os.path.relpath(fullPath, basePath))
 481         return sorted(collectedFiles)
 482
 483     def getVars( self ):
 484         vars = wcomponents.WTemplated.getVars( self )
 485         styleMgr = info.HelperMaKaCInfo.getMaKaCInfoInstance().getStyleManager()
 486         vars["styleMgr"] = styleMgr
 487         baseTPLPath = styleMgr.getBaseTPLPath()
 488         baseCSSPath = styleMgr.getBaseCSSPath()
 489         baseXSLPath = styleMgr.getBaseXSLPath()
 490         vars["availableTemplates"] = self._getAllFiles(baseTPLPath, '.tpl', excludedDirs=['include'])
 491         vars["availableStyleSheets"] = self._getAllFiles(baseXSLPath, '.xsl', excludedDirs=['include'])
 492         vars["availableCSS"] = self._getAllFiles(baseCSSPath, '.css')
 493         vars["xslContextHelpText"] = r"Lists all XSL files in %s (except special folders named \'include\', which are reserved)" % baseXSLPath
 494         vars["tplContextHelpText"] = r"Lists all TPL files in %s (except special folders named \'include\', which are reserved)" % baseTPLPath
 495         vars["cssContextHelpText"] = "Lists all CSS files in %s" % baseCSSPath
 496         return vars
 497
 498 class WAdminTemplates(wcomponents.WTemplated):
 499
 500     def getVars( self ):
 501         vars = wcomponents.WTemplated.getVars( self )
 502         return vars
 503
 504 class WPBadgeTemplates(WPBadgeTemplatesBase):
 505     pageURL = "badgeTemplates.py"
 506
 507     def __init__(self, rh):
 508         WPBadgeTemplatesBase.__init__(self, rh)
 509
 510     def _getTabContent( self, params ):
 511         wp = WBadgeTemplates(conference.CategoryManager().getDefaultConference())
 512         return wp.getHTML(params)
 513
 514     def _setActiveTab( self ):
 515         self._subTabBadges.setActive()
 516
 517
 518 class WPPosterTemplates(WPBadgeTemplatesBase):
 519     pageURL = "posterTemplates.py"
 520
 521     def __init__(self, rh):
 522         WPBadgeTemplatesBase.__init__(self, rh)
 523
 524     def _getTabContent( self, params ):
 525         wp = WPosterTemplates(conference.CategoryManager().getDefaultConference())
 526         return wp.getHTML(params)
 527
 528     def _setActiveTab(self):
 529         self._subTabPosters.setActive()
 530
 531
 532 class WPBadgeTemplateDesign(WPBadgeTemplatesBase):
 533
 534     def __init__(self, rh, conf, templateId=None, new=False):
 535         WPBadgeTemplatesBase.__init__(self, rh)
 536         self._conf = conf
 537         self.__templateId = templateId
 538         self.__new = new
 539
 540     def _setActiveTab(self):
 541         self._subTabBadges.setActive()
 542
 543     def _getTabContent(self, params):
 544         wc = conferences.WConfModifBadgeDesign(self._conf, self.__templateId, self.__new)
 545         return wc.getHTML()
 546
 547
 548 class WPPosterTemplateDesign(WPBadgeTemplatesBase):
 549
 550     def __init__(self, rh, conf, templateId=None, new=False):
 551         WPBadgeTemplatesBase.__init__(self, rh)
 552         self._conf = conf
 553         self.__templateId = templateId
 554         self.__new = new
 555
 556     def _setActiveTab(self):
 557         self._subTabPosters.setActive()
 558
 559     def _getTabContent(self, params):
 560         wc = conferences.WConfModifPosterDesign(self._conf, self.__templateId, self.__new)
 561         return wc.getHTML()
 562
 563
 564 class WBadgePosterTemplatingBase(wcomponents.WTemplated):
 565
 566     DEF_TEMPLATE_BADGE = None
 567
 568     def __init__(self, conference, user=None):
 569         wcomponents.WTemplated.__init__(self)
 570         self._conf = conference
 571         self._user = user
 572
 573     def getVars(self):
 574         uh = urlHandlers
 575         vars = wcomponents.WTemplated.getVars(self)
 576         vars['NewDefaultTemplateURL'] = str(self.DEF_TEMPLATE_BADGE.getURL(self._conf,
 577                                                                              self._conf.getBadgeTemplateManager().getNewTemplateId(), new=True))
 578
 579         vars['templateList'] = self._getTemplates()
 580         self._addExtras(vars)
 581
 582         return vars
 583
 584     def _getConfTemplates(self):
 585         """
 586         To be overridden in inheriting class.
 587         """
 588         pass
 589
 590     def _getTemplates(self):
 591         templates = []
 592         rawTemplates = self._getConfTemplates()
 593         rawTemplates.sort(lambda x, y: cmp(x[1].getName(), y[1].getName()))
 594
 595         for templateId, template in rawTemplates:
 596             templates.append(self._processTemplate(templateId, template))
 597
 598         return templates
 599
 600     def _addExtras(self, vars):
 601         """
 602         To be overridden in inheriting class, adds specific entries
 603         into the dictionary vars which the child implementation may require.
 604         """
 605         pass
 606
 607     def _processTemplate(self, templateId, template):
 608         """
 609         To be overridden in inheriting class, takes the template and its
 610         ID, the child then processes the data into the format it expects later.
 611         """
 612         pass
 613
 614
 615 class WBadgeTemplates(WBadgePosterTemplatingBase):
 616
 617     DEF_TEMPLATE_BADGE = urlHandlers.UHModifDefTemplateBadge
 618
 619     def _addExtras(self, vars):
 620         vars['PDFOptions'] = WConfModifBadgePDFOptions(self._conf,
 621                                                        showKeepValues=False,
 622                                                        showTip=False).getHTML()
 623
 624     def _getConfTemplates(self):
 625         return self._conf.getBadgeTemplateManager().getTemplates().items()
 626
 627     def _processTemplate(self, templateId, template):
 628         uh = urlHandlers
 629
 630         data = {
 631             'name': template.getName(),
 632             'urlEdit': str(uh.UHConfModifBadgeDesign.getURL(self._conf, templateId)),
 633             'urlDelete': str(uh.UHConfModifBadgePrinting.getURL(self._conf, deleteTemplateId=templateId))
 634         }
 635
 636         return data
 637
 638
 639 class WPosterTemplates(WBadgePosterTemplatingBase):
 640
 641     DEF_TEMPLATE_BADGE = urlHandlers.UHModifDefTemplatePoster
 642
 643     def _getConfTemplates(self):
 644         return self._conf.getPosterTemplateManager().getTemplates().items()
 645
 646     def _processTemplate(self, templateId, template):
 647         uh = urlHandlers
 648
 649         data = {
 650             'name': template.getName(),
 651             'urlEdit': str(uh.UHConfModifPosterDesign.getURL(self._conf, templateId)),
 652             'urlDelete': str(uh.UHConfModifPosterPrinting.getURL(self._conf, deleteTemplateId=templateId)),
 653             'urlCopy': str(uh.UHConfModifPosterPrinting.getURL(self._conf, copyTemplateId=templateId))
 654         }
 655
 656         return data
 657
 658
 659 class WPDomainBase( WPAdminsBase ):
 660
 661     def __init__( self, rh ):
 662         WPAdminsBase.__init__( self, rh )
 663
 664     def _setActiveSideMenuItem( self ):
 665         self._domainsMenuItem.setActive()
 666
 667 class WBrowseDomains( wcomponents.WTemplated ):
 668
 669     def __init__( self, letter=None ):
 670         self._letter = letter
 671
 672     def getVars( self ):
 673         vars = wcomponents.WTemplated.getVars( self )
 674         dh = domain.DomainHolder()
 675         letters = dh.getBrowseIndex()
 676         vars["browseIndex"] = i18nformat("""
 677         <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.disable=1;document.browseForm.submit();return false;">_("clear")</a></span>""")
 678         if self._letter == "all":
 679             vars["browseIndex"] += """
 680         [all] """
 681         else:
 682             vars["browseIndex"] += i18nformat("""
 683         <span class="nav_border"><a href='' class="nav_link" onClick="document.browseForm.letter.value='all';document.browseForm.submit();return false;">_("all")</a></span> """)
 684         for letter in letters:
 685             if self._letter == letter:
 686                 vars["browseIndex"] += """\n[%s] """ % letter
 687             else:
 688                 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)
 689         vars["browseResult"] = ""
 690         res = []
 691         if self._letter not in [ None, "" ]:
 692             if self._letter != "all":
 693                 res = dh.matchFirstLetter(self._letter)
 694             else:
 695                 res = dh.getValuesToList()
 696             res.sort(utils.sortDomainsByName)
 697             vars["browseResult"] = WHTMLDomainList(vars,res).getHTML()
 698         return vars
 699
 700 class WDomainList(wcomponents.WTemplated):
 701
 702     def __init__( self, criteria, params ):
 703         self._criteria = criteria
 704         self._params = params
 705
 706     def _performSearch( self, criteria ):
 707         dh = domain.DomainHolder()
 708         res = dh.match(criteria)
 709         return res
 710
 711     def getVars( self ):
 712         vars = wcomponents.WTemplated.getVars( self )
 713         vars["createDomainURL"] = urlHandlers.UHNewDomain.getURL()
 714         vars["nbDomains"] = domain.DomainHolder().getLength()
 715         vars["browseDomains"] = WBrowseDomains(self._params.get("letter",None)).getHTML(vars)
 716         vars["browseDomainsURL"] = urlHandlers.UHDomains.getURL()
 717         vars["searchDomainsURL"] = urlHandlers.UHDomains.getURL()
 718         vars["domains"] = ""
 719         if self._criteria:
 720             domainList = self._performSearch(self._criteria)
 721             vars["domains"] = WHTMLDomainList(vars,domainList).getHTML()
 722         return vars
 723
 724 class WHTMLDomainList:
 725
 726     def __init__(self, vars, list):
 727         self._vars = vars
 728         self._list = list
 729
 730     def getHTML(self):
 731         text = """<tr>
 732                               <td>
 733                     <br>
 734                 <table width="100%%" align="left" style="border-top: 1px solid #777777; padding-top:10px">"""
 735         color="white"
 736         ul = []
 737         for dom in self._list:
 738             if color=="white":
 739                 color="#F6F6F6"
 740             else:
 741                 color="white"
 742             url = self._vars["domainDetailsURLGen"]( dom )
 743             ul.append("""<tr>
 744                             <td bgcolor="%s"><a href="%s">%s</a></td>
 745                         </tr>"""%(color, url, dom.getName() or _("no name") ) )
 746         if ul:
 747             text += "".join( ul )
 748         else:
 749             text += """<tr>
 750                         <td><br><span class="blacktext">&nbsp;&nbsp;&nbsp;No domains for this search</span></td></tr>"""
 751         text += """    </table>
 752                       </td>
 753                 </tr>"""
 754         return text
 755
 756 class WPDomainList( WPDomainBase ):
 757
 758     def __init__( self, rh, params ):
 759         WPDomainBase.__init__( self, rh )
 760         self._params = params
 761
 762     def _getPageContent( self, params ):
 763         criteria = {}
 764         if self._params.get("sName","") != "":
 765             criteria["name"] = self._params.get("sName","")
 766         comp = WDomainList(criteria,self._params)
 767         pars = {"domainDetailsURLGen": urlHandlers.UHDomainDetails.getURL }
 768         return comp.getHTML(pars)
 769
 770
 771 class WDomainDetails(wcomponents.WTemplated):
 772
 773     def __init__( self, dom):
 774         self._domain = dom
 775
 776     def getVars( self ):
 777         vars = wcomponents.WTemplated.getVars( self )
 778         vars["name"] = self._domain.getName()
 779         vars["description"] = self._domain.getDescription()
 780         vars["filters"] = "<br>".join(self._domain.getFilterList())
 781         return vars
 782
 783
 784 class WPDomainDetails( WPDomainBase ):
 785
 786     def __init__(self, rh, domain):
 787         WPDomainBase.__init__(self, rh)
 788         self._domain = domain
 789
 790     def _getPageContent( self, params ):
 791         comp = WDomainDetails( self._domain )
 792         pars = {"modifyURL": urlHandlers.UHDomainModification.getURL( self._domain ) }
 793         return comp.getHTML( pars )
 794
 795
 796 class WDomainDataModification(wcomponents.WTemplated):
 797
 798     def __init__( self, dom ):
 799         self._domain = dom
 800
 801     def getVars( self ):
 802         vars = wcomponents.WTemplated.getVars( self )
 803         vars["name"] = self._domain.getName()
 804         vars["description"] = self._domain.getDescription()
 805         vars["filters"] = ";".join( self._domain.getFilterList() )
 806         vars["locator"] = self._domain.getLocator().getWebForm()
 807         return vars
 808
 809
 810 class WPDomainModification( WPDomainBase ):
 811
 812     def __init__(self, rh, domain):
 813         WPDomainBase.__init__(self, rh)
 814         self._domain = domain
 815
 816     def _getPageContent( self, params ):
 817         comp = WDomainDataModification( self._domain )
 818         pars = {
 819             'postURL': urlHandlers.UHDomainPerformModification.getURL(self._domain)
 820         }
 821         return comp.getHTML( pars )
 822
 823
 824 class WDomainCreation(wcomponents.WTemplated):
 825     pass
 826
 827
 828 class WPDomainCreation( WPDomainBase ):
 829
 830     def _getPageContent( self, params ):
 831         comp = WDomainCreation()
 832         pars = {"postURL": urlHandlers.UHDomainPerformCreation.getURL()}
 833         return comp.getHTML( pars )
 834
 835
 836 class WPAdminsSystemBase(WPAdminsBase):
 837     def __init__(self, rh):
 838         WPAdminsBase.__init__(self, rh)
 839
 840     def _setActiveSideMenuItem(self):
 841         self._systemMenuItem.setActive()
 842
 843     def _createTabCtrl(self):
 844         self._tabCtrl = wcomponents.TabControl()
 845
 846         self._subTabConfiguration = self._tabCtrl.newTab("configuration", _("Configuration"),
 847                                                          urlHandlers.UHAdminsSystem.getURL())
 848         self._subTabMaintenance = self._tabCtrl.newTab("maintenance", _("Maintenance"),
 849                                                        urlHandlers.UHMaintenance.getURL())
 850
 851     def _getPageContent(self, params):
 852         return wcomponents.WTabControl(self._tabCtrl, self._getAW()).getHTML(self._getTabContent(params))
 853
 854
 855 class WPAdminsSystem(WPAdminsSystemBase):
 856
 857     def _setActiveTab(self):
 858         self._subTabConfiguration.setActive()
 859
 860     def _getTabContent(self, params):
 861         wc = WAdminsSystem()
 862         return wc.getHTML(params)
 863
 864
 865 class WAdminsSystem(wcomponents.WTemplated):
 866
 867     def getVars(self):
 868         vars = wcomponents.WTemplated.getVars(self)
 869         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 870         vars["minfo"] = minfo
 871         vars["ModifURL"] = urlHandlers.UHAdminsSystemModif.getURL()
 872         vars['use_proxy'] = Config.getInstance().getUseProxy()
 873         return vars
 874
 875
 876 class WPAdminsSystemModif(WPAdminsSystemBase):
 877
 878     def _getTabContent(self, params):
 879         wc = WAdminsSystemModif()
 880         return wc.getHTML(params)
 881
 882
 883 class WAdminsSystemModif(wcomponents.WTemplated):
 884
 885     def getVars(self):
 886         vars = wcomponents.WTemplated.getVars(self)
 887         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 888         vars["minfo"] = minfo
 889         vars["postURL"] = urlHandlers.UHAdminsSystemModif.getURL()
 890         return vars
 891
 892
 893 class WPMaintenanceBase(WPAdminsSystemBase):
 894
 895     def __init__(self, rh):
 896         WPAdminsBase.__init__(self, rh)
 897
 898     def _setActiveTab(self):
 899         self._subTabMaintenance.setActive()
 900
 901
 902 class WPMaintenance(WPMaintenanceBase):
 903
 904     def __init__(self, rh, s, dbSize):
 905         WPMaintenanceBase.__init__(self, rh)
 906         self._stat = s
 907         self._dbSize = dbSize
 908
 909     def _getTabContent(self, params):
 910         wc = WAdminMaintenance()
 911         pars = { "cleanupURL": urlHandlers.UHMaintenanceTmpCleanup.getURL(), \
 912                  "tempSize": self._stat[0], \
 913                  "nFiles": "%s files" % self._stat[1], \
 914                  "nDirs": "%s folders" % self._stat[2], \
 915                  "packURL": urlHandlers.UHMaintenancePack.getURL(), \
 916                  "dbSize": self._dbSize}
 917         return wc.getHTML(pars)
 918
 919
 920 class WAdminMaintenance(wcomponents.WTemplated):
 921
 922     def getVars(self):
 923         vars = wcomponents.WTemplated.getVars(self)
 924         return vars
 925
 926
 927 class WPMaintenanceTmpCleanup(WPMaintenanceBase):
 928
 929     def __init__(self, rh):
 930         WPMaintenanceBase.__init__(self, rh)
 931
 932     def _getTabContent(self, params):
 933         msg = """Are you sure you want to delete the temporary directory
 934         (note that all the files in that directory will be deleted)?"""
 935         wc = wcomponents.WConfirmation()
 936         url = urlHandlers.UHMaintenancePerformTmpCleanup.getURL()
 937         return """
 938                 <table align="center" width="95%%">
 939                     <tr>
 940                         <td class="formTitle">Maintenance: Cleaning-up temporary directory</td>
 941                     </tr>
 942                     <tr>
 943                         <td>
 944                     <br>
 945                             %s
 946                         </td>
 947                     </tr>
 948                 </table>
 949                 """ % wc.getHTML(msg, url, {})
 950
 951
 952 class WPMaintenancePack(WPMaintenanceBase):
 953
 954     def __init__(self, rh):
 955         WPMaintenanceBase.__init__(self, rh)
 956
 957     def _getTabContent(self, params):
 958         wc = wcomponents.WConfirmation()
 959         msg = """Are you sure you want to pack the database?"""
 960         url = urlHandlers.UHMaintenancePerformPack.getURL()
 961         return """
 962                 <table align="center" width="95%%">
 963                     <tr>
 964                         <td class="formTitle">Maintenance: Database packing</td>
 965                     </tr>
 966                     <tr>
 967                         <td>
 968                     <br>
 969                             %s
 970                         </td>
 971                     </tr>
 972                 </table>
 973                 """ % wc.getHTML(msg, url, {})
 974
 975
 976 class WPIPBasedACL( WPServicesCommon ):
 977
 978     def __init__( self, rh ):
 979         WPServicesCommon.__init__( self, rh )
 980
 981     def _getTabContent(self, params):
 982         wc = WIPBasedACL()
 983         return wc.getHTML(params)
 984
 985     def _setActiveTab(self):
 986         self._subTabIPBasedACL.setActive()
 987
 988
 989 class WIPBasedACL(wcomponents.WTemplated):
 990
 991     def getVars(self):
 992         vars = wcomponents.WTemplated.getVars(self)
 993         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
 994         vars["ipList"] = minfo.getIPBasedACLMgr().get_full_access_acl()
 995         vars["removeIcon"] = Config.getInstance().getSystemIconURL("remove")
 996         return vars
 997
 998
 999 class WPAdminProtection(WPAdminsBase):
1000
1001     def _setActiveSideMenuItem(self):
1002         self._protectionMenuItem.setActive()
1003
1004     def _getPageContent(self, params):
1005         wc = WAdminProtection()
1006         return wc.getHTML()
1007
1008
1009 class WAdminProtection(wcomponents.WTemplated):
1010
1011     def getVars(self):
1012         vars = wcomponents.WTemplated.getVars(self)
1013         minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1014         vars["protectionDisclaimerProtected"] = minfo.getProtectionDisclaimerProtected()
1015         vars["protectionDisclaimerRestricted"] = minfo.getProtectionDisclaimerRestricted()
1016         return vars