Esempio n. 1
0
 def _process(self):
     try:
         user = self._request_token.getUser()
         access_tokens = Catalog.getIdx('user_oauth_access_token').get(user.getId())
         timestamp = nowutc()
         if access_tokens is not None:
             for access_token in list(access_tokens):
                 if access_token.getConsumer().getName() == self._request_token.getConsumer().getName():
                     access_token.setTimestamp(timestamp)
                     response = {'oauth_token': access_token.getId(),
                                 'oauth_token_secret': access_token.getToken().secret,
                                 'user_id': user.getId(),
                                 'oauth_token_ttl': Config.getInstance().getOAuthAccessTokenTTL(),
                                 'oauth_token_expiration_timestamp': access_token.getTimestamp() +
                                 timedelta(seconds=Config.getInstance().getOAuthAccessTokenTTL())}
                     return urlencode(response)
         access_token_key = OAuthUtils.gen_random_string()
         access_token_secret = OAuthUtils.gen_random_string()
         access_token = Token(access_token_key, oauth.Token(access_token_key, access_token_secret),
                              timestamp, self._request_token.getConsumer(), user)
         AccessTokenHolder().add(access_token)
         response = {'oauth_token': access_token_key,
                     'oauth_token_secret': access_token_secret,
                     'user_id': user.getId(),
                     'oauth_token_ttl': Config.getInstance().getOAuthAccessTokenTTL(),
                     'oauth_token_expiration_timestamp': access_token.getTimestamp() +
                     timedelta(seconds=Config.getInstance().getOAuthAccessTokenTTL())}
         return urlencode(response)
     except oauth.Error, err:
         raise OAuthError(err.message, 401)
Esempio n. 2
0
 def _checkCSRF(self):
     token = request.headers.get('X-CSRF-Token', request.form.get('csrf_token'))
     if self.CSRF_ENABLED and request.method != 'GET' and token != session.csrf_token:
         msg = _(u"It looks like there was a problem with your current session. Please use your browser's back "
                 u"button, reload the page and try again.")
         raise BadRequest(msg)
     elif not self.CSRF_ENABLED and current_app.debug and request.method != 'GET':
         # Warn if CSRF is not enabled for a RH in new code
         module = self.__class__.__module__
         if module.startswith('indico.modules.') or module.startswith('indico.core.'):
             msg = (u'{} request sent to {} which has no CSRF checks. Set `CSRF_ENABLED = True` in the class to '
                    u'enable them.').format(request.method, self.__class__.__name__)
             warnings.warn(msg, RuntimeWarning)
     # legacy csrf check (referer-based):
     # Check referer for POST requests. We do it here so we can properly use indico's error handling
     if Config.getInstance().getCSRFLevel() < 3 or request.method != 'POST':
         return
     referer = request.referrer
     # allow empty - otherwise we might lock out paranoid users blocking referers
     if not referer:
         return
     # valid http referer
     if referer.startswith(Config.getInstance().getBaseURL()):
         return
     # valid https referer - if https is enabled
     base_secure = Config.getInstance().getBaseSecureURL()
     if base_secure and referer.startswith(base_secure):
         return
     raise BadRefererError('This operation is not allowed from an external referer.')
Esempio n. 3
0
    def _prepare(self, check = True):

        # Date checks...
        if check:
            from MaKaC.conference import ConferenceHolder
            if not ConferenceHolder().hasKey(self.conf.getId()):
                self.getLogger().warning("Conference %s no longer exists! "
                                     "Deleting alarm." % self.conf.getId())
                self.conf.removeAlarm(self)
                self.suicide()
            elif self.conf.getStartDate() <= self._getCurrentDateTime():
                self.getLogger().warning("Conference %s already started. "
                                     "Deleting alarm." % self.conf.getId())
                self.conf.removeAlarm(self)
                self.suicide()
                return False

        # Email
        startDateTime = format_datetime(self.conf.getAdjustedStartDate(), format="short")
        self.setUpSubject()
        try:
            locationText = self.conf.getLocation().getName()
            if self.conf.getLocation().getAddress() != "":
                locationText += ", %s" % self.conf.getLocation().getAddress()
            if self.conf.getRoom().getName() != "":
                locationText += " (%s)" % self.conf.getRoom().getName()
        except:
            locationText = ""
        if locationText != "":
            locationText = " %s: %s" % ( _("Location"), locationText)

        if self.getToAllParticipants() :
            if self.conf.getType() == "conference":
                for r in self.conf.getRegistrantsList():
                    self.addToUser(r)
            else:
                for p in self.conf.getParticipation().getParticipantList() :
                    self.addToUser(p)
        from MaKaC.webinterface import urlHandlers
        if Config.getInstance().getShortEventURL() != "":
            url = "%s%s" % (Config.getInstance().getShortEventURL(),self.conf.getId())
        else:
            url = urlHandlers.UHConferenceDisplay.getURL(self.conf)
        self.setText("""Hello,
    Please note that the event "%s" will start on %s (%s).
    %s

    You can access the full event here:
    %s

Best Regards

""" % (self.conf.getTitle(),\
                startDateTime,\
                self.conf.getTimezone(),\
                locationText,\
                url,\
                ))
        self._setMailText()
        return True
Esempio n. 4
0
    def _process(self):
        flower_url = Config.getInstance().getFlowerURL()

        notset = object()
        overridden_tasks = Config.getInstance().getScheduledTaskOverride()
        tasks = []
        for entry in celery.conf['CELERYBEAT_SCHEDULE'].values():
            override = overridden_tasks.get(entry['task'], notset)
            custom_schedule = None
            disabled = False
            if override is notset:
                pass
            elif not override:
                disabled = True
            elif isinstance(override, dict):
                custom_schedule = override.get('schedule')
            else:
                custom_schedule = override

            tasks.append({'name': entry['task'],
                          'schedule': entry['schedule'],
                          'custom_schedule': custom_schedule,
                          'disabled': disabled})
        tasks.sort(key=itemgetter('disabled', 'name'))

        return WPCelery.render_template('celery_tasks.html', flower_url=flower_url, tasks=tasks, timedelta=timedelta)
Esempio n. 5
0
    def _connect(self):
        """Connect to the CacheClient.

        This method must be called before accessing ``self._client``.
        """
        # Maybe we already have a client in this instance
        if self._client is not None:
            return
        # If not, we might have one from another instance
        self._client = ContextManager.get('GenericCacheClient', None)

        if self._client is not None:
            return

        # If not, create a new one
        backend = Config.getInstance().getCacheBackend()
        if backend == 'memcached':
            self._client = MemcachedCacheClient(Config.getInstance().getMemcachedServers())
        elif backend == 'redis':
            self._client = RedisCacheClient(Config.getInstance().getRedisCacheURL())
        elif backend == 'files':
            self._client = FileCacheClient(Config.getInstance().getXMLCacheDir())
        else:
            self._client = NullCacheClient()

        ContextManager.set('GenericCacheClient', self._client)
Esempio n. 6
0
File: base.py Progetto: NIIF/indico
    def _processUnexpectedError(self, e):
        """Unexpected errors"""

        self._responseUtil.redirect = None
        if Config.getInstance().getEmbeddedWebserver() or Config.getInstance().getPropagateAllExceptions():
            raise
        return errors.WPUnexpectedError(self).display()
Esempio n. 7
0
def pytest_configure(config):
    # Load all the plugins defined in pytest_plugins
    config.pluginmanager.consider_module(sys.modules[__name__])
    config.indico_temp_dir = py.path.local(tempfile.mkdtemp(prefix='indicotesttmp.'))
    plugins = filter(None, [x.strip() for x in re.split(r'[\s,;]+', config.getini('indico_plugins'))])
    # Throw away all indico.conf options early
    Config.getInstance().reset({
        'DBConnectionParams': ('localhost', 0),  # invalid port - just so we never connect to a real ZODB!
        'SmtpServer': ('localhost', 0),  # invalid port - just in case so we NEVER send emails!
        'CacheBackend': 'null',
        'Loggers': [],
        'UploadedFilesTempDir': config.indico_temp_dir.strpath,
        'XMLCacheDir': config.indico_temp_dir.strpath,
        'ArchiveDir': config.indico_temp_dir.strpath,
        'StorageBackends': {'default': config.indico_temp_dir},
        'AttachmentStorage': 'default',
        'Plugins': plugins,
        'SecretKey': os.urandom(16)
    })
    # Make sure we don't write any log files (or worse: send emails)
    Logger.reset()
    del logging.root.handlers[:]
    logging.root.addHandler(logging.NullHandler())
    # Silence the annoying pycountry logger
    import pycountry.db
    pycountry.db.logger.addHandler(logging.NullHandler())
Esempio n. 8
0
    def run(self, template_name, **kwargs):
        template_dir = os.path.join(Config.getInstance().getTPLDir(), 'latex')
        template = tpl_render(os.path.join(template_dir, template_name), kwargs)

        self._dir = tempfile.mkdtemp(prefix="indico-texgen-", dir=Config.getInstance().getTempDir())
        source_filename = os.path.join(self._dir, template_name + '.tex')
        target_filename = os.path.join(self._dir, template_name + '.pdf')
        log_filename = os.path.join(self._dir, 'output.log')
        log_file = open(log_filename, 'a+')

        with open(source_filename, 'w') as f:
            f.write(template)

        try:
            self.run_latex(source_filename, log_file)
            if self.has_toc:
                self.run_latex(source_filename, log_file)
        finally:
            log_file.close()

            if not os.path.exists(target_filename):
                report_no = self._save_error_report(source_filename, log_filename)
                # something went terribly wrong, no LaTeX file was produced
                raise LaTeXRuntimeException(source_filename, log_filename, report_no, kwargs)

        return target_filename
Esempio n. 9
0
    def sanitizationCheck(target, params, accessWrapper, doNotSanitize=[]):
        # first make sure all params are utf-8
        Sanitization._encodeUnicode(params)

        # then check the security level of data sent to the server
        # if no user logged in, then no html allowed
        if accessWrapper.getUser():
            level = Config.getInstance().getSanitizationLevel()
        elif target and hasattr(target, "canModify") and target.canModify(accessWrapper):
            # not logged user, but use a modification key
            level = Config.getInstance().getSanitizationLevel()
        else:
            level = 0

        if level not in range(4):
            level = 1

        if level == 0:
            #Escape all HTML tags
            Sanitization._escapeHTML(params, doNotSanitize)

        elif level in [1, 2]:
            #level 1 or default: raise error if script or style detected
            #level 2: raise error if script but style accepted
            Sanitization._sanitize(params, level, doNotSanitize)

        elif level == 3:
            # Absolutely no checks
            return
Esempio n. 10
0
    def _send(msgData):
        server = smtplib.SMTP(*Config.getInstance().getSmtpServer())
        if Config.getInstance().getSmtpUseTLS():
            server.ehlo()
            (code, errormsg) = server.starttls()
            if code != 220:
                raise MaKaCError(_("Can't start secure connection to SMTP server: %d, %s") % (code, errormsg))
        if Config.getInstance().getSmtpLogin():
            login = Config.getInstance().getSmtpLogin()
            password = Config.getInstance().getSmtpPassword()
            (code, errormsg) = server.login(login, password)
            if code != 235:
                raise MaKaCError(_("Can't login on SMTP server: %d, %s") % (code, errormsg))

        to_addrs = msgData["toList"] | msgData["ccList"] | msgData["bccList"]
        try:
            Logger.get("mail").info(
                "Sending email: To: {} / CC: {} / BCC: {}".format(
                    ", ".join(msgData["toList"]) or "None",
                    ", ".join(msgData["ccList"]) or "None",
                    ", ".join(msgData["bccList"]) or "None",
                )
            )
            server.sendmail(msgData["fromAddr"], to_addrs, msgData["msg"])
        except smtplib.SMTPRecipientsRefused as e:
            raise MaKaCError("Email address is not valid: {}".format(e.recipients))
        finally:
            server.quit()
        Logger.get("mail").info("Mail sent to {}".format(", ".join(to_addrs)))
Esempio n. 11
0
File: admins.py Progetto: fph/indico
    def __getAvailableTemplates(self):
        tplDir = Config.getInstance().getTPLDir()

        tplRE = re.compile('^([^\.]+)\.([^\.]+)\.tpl$')

        templates = {}

        fnames = os.listdir(tplDir);
        for fname in fnames:
            m = tplRE.match(fname)
            if m:
                templates[m.group(2)] = None

        tplRE = re.compile('^([^\.]+)\.([^\.]+)\.wohl$')

        fnames = os.listdir(os.path.join(tplDir, 'chelp'))
        for fname in fnames:
            m = tplRE.match(fname)
            if m:
                templates[m.group(2)] = None

        cssRE = re.compile('Default.([^\.]+)\.css$')

        fnames = os.listdir(Config.getInstance().getCssDir())
        for fname in fnames:
            m = cssRE.match(fname)
            if m:
                templates[m.group(1)] = None

        return templates.keys()
Esempio n. 12
0
    def deleted(self, obj, oldOwner):
        print "****DELETING OBJ=",obj, oldOwner

        objClass = type(oldOwner).__name__
        objClassTitle = oldOwner.getTitle().lower()

        if objClass == 'Poster':
            objType = obj.getFileType().lower()
            objName = obj.getFileName().lower()
            if objName.find('poster') > -1 and objType == 'pdf' and objName.find('list_of_poster') == -1 and objName.find('session') == -1:
                # If POSTER is present, remove it
                tempDir = Config.getInstance().getSharedTempDir()
                postersDir = tempDir+"/posters"
                if os.path.isdir(postersDir):
                    confId = str(oldOwner.owner.getId())
                    thumbPath = postersDir + "/poster_" + confId
                    if os.path.isfile(thumbPath):
                        os.remove(thumbPath)
        else:
            if (objClassTitle.find('photo') > -1 or objClassTitle.find('picture') > -1 or objClassTitle.find('group') > -1):
                objType = obj.getFileType().lower()
                objName = obj.getFileName().lower()
                if (objType == 'jpg'):
                    # If Group Photo is present, remove it
                    tempDir = Config.getInstance().getSharedTempDir()
                    photoDir = tempDir+"/photos"
                    if os.path.isdir(photoDir):
                        confId = str(oldOwner.owner.getId())
                        thumbPath = photoDir + "/photo_" + confId + "_" + objName
                        if os.path.isfile(thumbPath):
                            os.remove(thumbPath)
        return
Esempio n. 13
0
    def alertCreation(self, confs):
        conf = confs[0]
        fromAddr = Config.getInstance().getSupportEmail()
        addrs = [ Config.getInstance().getSupportEmail() ]
        eventType = conf.getType()
        if eventType == "conference":
            type = "conference"
        elif eventType == "meeting":
            type = "meeting"
        else:
            type = "lecture"
        chair = ""
        if conf.getChairmanText() != "":
            chair = conf.getChairmanText()
        else:
            for c in conf.getChairList():
                chair += c.getFullName() + "; "
        subject = "New %s in indico (%s)" % (type,conf.getId())
        if conf.getRoom() != None:
            room = conf.getRoom().getName()
        else:
            room = ""
        text = """
_Category_
%s
_Title_
%s
_Speaker/Chair_
%s
_Room_
%s
_Description_
%s
_Creator_
%s (%s)"""%(conf.getOwner().getTitle(), conf.getTitle(), chair, room, conf.getDescription(), conf.getCreator().getFullName(), conf.getCreator().getId())
        if len(confs) == 1:
            text += """
_Date_
%s -> %s
_Access_
%s""" % ( conf.getAdjustedStartDate(), conf.getAdjustedEndDate(), urlHandlers.UHConferenceDisplay.getURL(conf))
        else:
            i = 1
            for c in confs:
                text += """
_Date%s_
%s -> %s
_Access%s_
%s """ % (i,c.getAdjustedStartDate(), c.getAdjustedEndDate(), i,urlHandlers.UHConferenceDisplay.getURL(c))
                i+=1

        msg = ("Content-Type: text/plain; charset=\"utf-8\"\r\nFrom: %s\r\nReturn-Path: %s\r\nTo: %s\r\nCc: \r\nSubject: %s\r\n\r\n"%(fromAddr, fromAddr, addrs, subject))
        msg = msg + text
        maildata = { "fromAddr": fromAddr, "toList": addrs, "subject": subject, "body": text }
        GenericMailer.send(maildata)
        # Category notification
        if conf.getOwner().getNotifyCreationList() != "":
            addrs2 = [ conf.getOwner().getNotifyCreationList() ]
            maildata2 = { "fromAddr": fromAddr, "toList": addrs2, "subject": subject, "body": text }
            GenericMailer.send(maildata2)
Esempio n. 14
0
    def _sendReport( self ):
        cfg = Config.getInstance()

        # if no e-mail address was specified,
        # add a default one
        if self._userMail:
            fromAddr = self._userMail
        else:
            fromAddr = '*****@*****.**'

        toAddr = Config.getInstance().getSupportEmail()
        Logger.get('errorReport').debug('mailing %s' % toAddr)
        subject = "[Indico@%s] Error report"%cfg.getBaseURL()

        request_info = self._requestInfo or ''
        if isinstance(request_info, (dict, list)):
            request_info = pformat(request_info)

        # build the message body
        body = [
            "-" * 20,
            "Error details\n",
            self._code,
            self._message,
            "Inner error: " + str(self._inner),
            request_info,
            "-" * 20
        ]
        maildata = {"fromAddr": fromAddr, "toList": [toAddr], "subject": subject, "body": "\n".join(body)}
        GenericMailer.send(GenericNotification(maildata))
Esempio n. 15
0
File: base.py Progetto: fph/indico
    def _getHTMLHeader( self ):
        from MaKaC.webinterface.rh.base import RHModificationBaseProtected
        from MaKaC.webinterface.rh.admins import RHAdminBase

        area=""
        if self.MANAGEMENT or isinstance(self._rh, RHModificationBaseProtected):
            area=i18nformat(""" - _("Management area")""")
        elif isinstance(self._rh, RHAdminBase):
            area=i18nformat(""" - _("Administrator area")""")

        plugin_css = values_from_signal(signals.plugin.inject_css.send(self.__class__), as_list=True,
                                        multi_value_types=list)
        plugin_js = values_from_signal(signals.plugin.inject_js.send(self.__class__), as_list=True,
                                       multi_value_types=list)

        return wcomponents.WHTMLHeader().getHTML({
            "area": area,
            "baseurl": self._getBaseURL(),
            "conf": Config.getInstance(),
            "page": self,
            "printCSS": map(self._fix_path, self.getPrintCSSFiles()),
            "extraCSS": map(self._fix_path, self.getCSSFiles() + plugin_css + self.get_extra_css_files()),
            "extraJSFiles": map(self._fix_path, self.getJSFiles() + plugin_js),
            "language": session.lang or Config.getInstance().getDefaultLocale(),
            # XXX: Remove SOCIAL_ENABLED once this is moved out of ZODB
            "social": HelperMaKaCInfo().getMaKaCInfoInstance().getSocialAppConfig() if self.SOCIAL_ENABLED else {},
            "assets": self._asset_env
        })
Esempio n. 16
0
File: util.py Progetto: NIIF/indico
def generate_public_auth_request(apiMode, apiKey, path, params={}, persistent=False, https=True):
    from indico.web.http_api import API_MODE_KEY, API_MODE_ONLYKEY, API_MODE_SIGNED, \
        API_MODE_ONLYKEY_SIGNED, API_MODE_ALL_SIGNED

    key = apiKey.getKey() if apiKey else None
    secret_key = apiKey.getSignKey() if apiKey else None
    if https:
        baseURL = Config.getInstance().getBaseSecureURL()
    else:
        baseURL = Config.getInstance().getBaseURL()
    publicRequestsURL = None
    authRequestURL = None
    if apiMode == API_MODE_KEY:
        publicRequestsURL = build_indico_request(path, params)
        authRequestURL = build_indico_request(path, params, key) if key else None
    elif apiMode == API_MODE_ONLYKEY:
        authRequestURL = build_indico_request(path, params, key) if key else None
        params["onlypublic"] = "yes"
        publicRequestsURL = build_indico_request(path, params, key) if key else None
    elif apiMode == API_MODE_SIGNED:
        publicRequestsURL = build_indico_request(path, params)
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key and secret_key else None
    elif apiMode == API_MODE_ONLYKEY_SIGNED:
        publicRequestsURL = build_indico_request(path, params, key)  if key else None
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key and secret_key else None
    elif apiMode == API_MODE_ALL_SIGNED:
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key else None
        params["onlypublic"] = "yes"
        publicRequestsURL = build_indico_request(path, params, key, secret_key, persistent)  if key else None
    return {"publicRequestURL": (baseURL + publicRequestsURL) if publicRequestsURL else "", "authRequestURL": (baseURL + authRequestURL) if authRequestURL else ""}
Esempio n. 17
0
File: base.py Progetto: Ictp/indico
    def _processUnexpectedError(self, e):
        """Unexpected errors"""

        if Config.getInstance().getEmbeddedWebserver() or Config.getInstance().getPropagateAllExceptions():
            # Re-raise to get the nice werkzeug exception view
            raise
        return errors.WPUnexpectedError(self).display()
Esempio n. 18
0
def set_best_lang(check_session=True):
    """
    Get the best language/locale for the current user. This means that first
    the session will be checked, and then in the absence of an explicitly-set
    language, we will try to guess it from the browser settings and only
    after that fall back to the server's default.
    """
    from indico.core.config import Config

    if not has_request_context():
        return 'en_GB' if current_app.config['TESTING'] else Config.getInstance().getDefaultLocale()
    elif 'lang' in g:
        return g.lang
    elif check_session and session.lang is not None:
        return session.lang

    # try to use browser language
    preferred = [x.replace('-', '_') for x in request.accept_languages.values()]
    resolved_lang = negotiate_locale(preferred, list(get_all_locales()), aliases=LOCALE_ALIASES)

    if not resolved_lang:
        if current_app.config['TESTING']:
            return 'en_GB'

        # fall back to server default
        resolved_lang = Config.getInstance().getDefaultLocale()

    # As soon as we looked up a language, cache it during the request.
    # This will be returned when accessing `session.lang` since there's code
    # which reads the language from there and might fail (e.g. by returning
    # lazy strings) if it's not set.
    g.lang = resolved_lang
    return resolved_lang
Esempio n. 19
0
    def getVars( self ):
        vars = wcomponents.WTemplated.getVars( self )
        vars["types"] = "<br>".join( self._getTypeFilterItemList() )
        vars["status"] = "<br>".join( self._getStatusFilterItemList() )
        vars["others"] = "<br>".join( self._getOthersFilterItemList() )
        vars["accTypes"] = "<br>".join( self._getAccTypeFilterItemList() )
        f = filters.SimpleFilter(self._filterCrit,self._sortingCrit)
        al = []
        abstractsToPrint = []
        self._checked = ""
        if vars["selectAll"]:
            self._checked = " checked"
        abstractList = f.apply( self._track.getAbstractList() )
        for abstract in abstractList:
            al.append( self._getAbstractHTML( abstract ) )
            abstractsToPrint.append("""<input type="hidden" name="abstracts" value="%s">"""%abstract.getId())
        vars["filteredNumberAbstracts"] = str(len(abstractList))
        vars["totalNumberAbstracts"] = str(len(self._track.getAbstractList()))
        if self._order == "up":
            al.reverse()
        vars["abstracts"] = "".join( al )
        vars["abstractsToPrint"] = "\n".join(abstractsToPrint)

        sortingField = self._sortingCrit.getField()
        vars["currentSorting"] = ""

        for crit in ["type", "status", "number", "date", "rating"]:
            url = self._getURL()

            vars["%sImg" % crit] = ""
            url.addParam("sortBy", crit)

            if sortingField.getId() == crit:
                vars["currentSorting"] = '<input type="hidden" name="sortBy" value="%s">' % crit
                if self._order == "down":
                    vars["%sImg" % crit] = """<img src="%s" alt="">"""%(Config.getInstance().getSystemIconURL("downArrow"))
                    url.addParam("order","up")
                elif self._order == "up":
                    vars["%sImg" % crit] = """<img src="%s" alt="">"""%(Config.getInstance().getSystemIconURL("upArrow"))
                    url.addParam("order","down")
            vars["%sSortingURL" % crit] = str(url)

        url = urlHandlers.UHTrackModifAbstracts.getURL( self._track )
        url.addParam("order", self._order)
        url.addParam("OK", "1")
        url.setSegment( "abstracts" )
        vars["filterPostURL"]=quoteattr(str(url))
        vars["accessAbstract"] = quoteattr(str(urlHandlers.UHTrackAbstractDirectAccess.getURL(self._track)))
        vars["allAbstractsURL"] = str(urlHandlers.UHConfAbstractManagment.getURL(self._conf))
        l = []
        for tpl in self._conf.getAbstractMgr().getNotificationTplList():
            l.append("""<option value="%s">%s</option>"""%(tpl.getId(), tpl.getName()))
        vars["notifTpls"] = "\n".join(l)
        vars["actionURL"]=quoteattr(str(urlHandlers.UHAbstractsTrackManagerAction.getURL(self._track)))
        vars["selectURL"]=quoteattr(str(urlHandlers.UHTrackModifAbstracts.getURL(self._track)))
        vars["filterUsed"] = self._filterUsed
        vars["resetFiltersURL"] = str(urlHandlers.UHTrackModifAbstracts.getURL(self._track))
        vars["pdfIconURL"] = quoteattr(str(Config.getInstance().getSystemIconURL("pdf")))
        vars["canModify"] = self._canModify
        return vars
Esempio n. 20
0
def generate_public_auth_request(apiKey, path, params=None):
    apiMode = api_settings.get('security_mode')
    if params is None:
        params = {}
    if apiKey:
        key = apiKey.token
        secret_key = apiKey.secret
        persistent = apiKey.is_persistent_allowed and api_settings.get('allow_persistent')
    else:
        key = secret_key = None
        persistent = False
    if api_settings.get('require_https'):
        baseURL = Config.getInstance().getBaseSecureURL()
    else:
        baseURL = Config.getInstance().getBaseURL()
    publicRequestsURL = None
    authRequestURL = None
    if apiMode == APIMode.KEY:
        publicRequestsURL = build_indico_request(path, params)
        authRequestURL = build_indico_request(path, params, key) if key else None
    elif apiMode == APIMode.ONLYKEY:
        authRequestURL = build_indico_request(path, params, key) if key else None
        params["onlypublic"] = "yes"
        publicRequestsURL = build_indico_request(path, params, key) if key else None
    elif apiMode == APIMode.SIGNED:
        publicRequestsURL = build_indico_request(path, params)
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key and secret_key else None
    elif apiMode == APIMode.ONLYKEY_SIGNED:
        publicRequestsURL = build_indico_request(path, params, key)  if key else None
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key and secret_key else None
    elif apiMode == APIMode.ALL_SIGNED:
        authRequestURL = build_indico_request(path, params, key, secret_key, persistent)  if key else None
        params["onlypublic"] = "yes"
        publicRequestsURL = build_indico_request(path, params, key, secret_key, persistent)  if key else None
    return {"publicRequestURL": (baseURL + publicRequestsURL) if publicRequestsURL else "", "authRequestURL": (baseURL + authRequestURL) if authRequestURL else ""}
Esempio n. 21
0
    def getVars( self ):
        from indico.web.http_api.util import generate_public_auth_request

        vars = WHeader.getVars( self )
        vars["categurl"] = self._conf.as_event.category.url

        vars["conf"] = vars["target"] = self._conf

        vars["imgLogo"] = Config.getInstance().getSystemIconURL("miniLogo")
        vars["MaKaCHomeURL"] = self._conf.as_event.category.url

        # Default values to avoid NameError while executing the template
        styles = theme_settings.get_themes_for("conference")

        vars["viewoptions"] = [{'id': theme_id, 'name': data['title']}
                               for theme_id, data in sorted(styles.viewitems(), key=lambda x: x[1]['title'])]
        vars["SelectedStyle"] = ""
        vars["pdfURL"] = ""
        vars["displayURL"] = str(urlHandlers.UHConferenceOtherViews.getURL(self._conf))

        # Setting the buttons that will be displayed in the header menu
        vars["showFilterButton"] = False
        vars["showMoreButton"] = True
        vars["showExportToICal"] = True
        vars["showExportToPDF"] = False
        vars["showDLMaterial"] = True
        vars["showLayout"] = True

        vars["displayNavigationBar"] = layout_settings.get(self._conf, 'show_nav_bar')

        # This is basically the same WICalExportBase, but we need some extra
        # logic in order to have the detailed URLs
        apiMode = api_settings.get('security_mode')

        vars["icsIconURL"] = str(Config.getInstance().getSystemIconURL("ical_grey"))
        vars["apiMode"] = apiMode
        vars["signingEnabled"] = apiMode in {APIMode.SIGNED, APIMode.ONLYKEY_SIGNED, APIMode.ALL_SIGNED}
        vars["persistentAllowed"] = api_settings.get('allow_persistent')
        user = self._aw.getUser()
        apiKey = user.api_key if user else None

        topURLs = generate_public_auth_request(apiKey, '/export/event/%s.ics' % self._conf.getId())
        urls = generate_public_auth_request(apiKey, '/export/event/%s.ics' % self._conf.getId(),
                                            {'detail': 'contributions'})

        vars["requestURLs"] = {
            'publicRequestURL': topURLs["publicRequestURL"],
            'authRequestURL':  topURLs["authRequestURL"],
            'publicRequestDetailedURL': urls["publicRequestURL"],
            'authRequestDetailedURL':  urls["authRequestURL"]
        }

        vars["persistentUserEnabled"] = apiKey.is_persistent_allowed if apiKey else False
        vars["apiActive"] = apiKey is not None
        vars["userLogged"] = user is not None
        tpl = get_template_module('api/_messages.html')
        vars['apiKeyUserAgreement'] = tpl.get_ical_api_key_msg()
        vars['apiPersistentUserAgreement'] = tpl.get_ical_persistent_msg()

        return vars
Esempio n. 22
0
    def process(self):
        """
        Processes the request, analyzing the parameters, and feeding them to the
        _getAnswer() method (implemented by derived classes)
        """

        ContextManager.set('currentRH', self)

        self._checkParams()
        self._checkProtection()

        if self.CHECK_HTML:
            try:
                security.Sanitization.sanitizationCheck(self._target, self._params, self._aw, ['requestInfo'])
            except HtmlForbiddenTag as e:
                raise HTMLSecurityError('ERR-X0', 'HTML Security problem. {}'.format(e))

        if self._doProcess:
            if Config.getInstance().getProfile():
                import profile, pstats, random
                proffilename = os.path.join(Config.getInstance().getTempDir(), "service%s.prof" % random.random())
                result = [None]
                profile.runctx("result[0] = self._getAnswer()", globals(), locals(), proffilename)
                answer = result[0]
                rep = Config.getInstance().getTempDir()
                stats = pstats.Stats(proffilename)
                stats.strip_dirs()
                stats.sort_stats('cumulative', 'time', 'calls')
                stats.dump_stats(os.path.join(rep, "IndicoServiceRequestProfile.log"))
                os.remove(proffilename)
            else:
                answer = self._getAnswer()
            self._deleteTempFiles()

            return answer
Esempio n. 23
0
    def _send(msgData):
        server=smtplib.SMTP(*Config.getInstance().getSmtpServer())
        if Config.getInstance().getSmtpUseTLS():
            server.ehlo()
            (code, errormsg) = server.starttls()
            if code != 220:
                raise MaKaCError( _("Can't start secure connection to SMTP server: %d, %s")%(code, errormsg))
        if Config.getInstance().getSmtpLogin():
            login = Config.getInstance().getSmtpLogin()
            password = Config.getInstance().getSmtpPassword()
            (code, errormsg) = server.login(login, password)
            if code != 235:
                raise MaKaCError( _("Can't login on SMTP server: %d, %s")%(code, errormsg))

        to_addrs = msgData['toList'] | msgData['ccList'] | msgData['bccList']
        try:
            Logger.get('mail').info('Sending email: To: {} / CC: {} / BCC: {}'.format(
                ', '.join(msgData['toList']) or 'None',
                ', '.join(msgData['ccList']) or 'None',
                ', '.join(msgData['bccList']) or 'None'))
            server.sendmail(msgData['fromAddr'], to_addrs, msgData['msg'])
        except smtplib.SMTPRecipientsRefused as e:
            raise MaKaCError('Email address is not valid: {}'.format(e.recipients))
        finally:
            server.quit()
        Logger.get('mail').info('Mail sent to {}'.format(', '.join(to_addrs)))
Esempio n. 24
0
def pytest_configure(config):
    # Load all the plugins defined in pytest_plugins
    config.pluginmanager.consider_module(sys.modules[__name__])
    config.indico_temp_dir = py.path.local(tempfile.mkdtemp(prefix="indicotesttmp."))
    plugins = filter(None, [x.strip() for x in re.split(r"[\s,;]+", config.getini("indico_plugins"))])
    # Throw away all indico.conf options early
    Config.getInstance().reset(
        {
            "DBConnectionParams": ("localhost", 0),  # invalid port - just so we never connect to a real ZODB!
            "SmtpServer": ("localhost", 0),  # invalid port - just in case so we NEVER send emails!
            "CacheBackend": "null",
            "Loggers": [],
            "UploadedFilesTempDir": config.indico_temp_dir.strpath,
            "XMLCacheDir": config.indico_temp_dir.strpath,
            "ArchiveDir": config.indico_temp_dir.strpath,
            "StorageBackends": {"default": config.indico_temp_dir},
            "AttachmentStorage": "default",
            "Plugins": plugins,
            "SecretKey": os.urandom(16),
        }
    )
    # Make sure we don't write any log files (or worse: send emails)
    Logger.reset()
    del logging.root.handlers[:]
    logging.root.addHandler(logging.NullHandler())
    # Silence the annoying pycountry logger
    import pycountry.db

    pycountry.db.logger.addHandler(logging.NullHandler())
Esempio n. 25
0
 def getVars(self):
     vars = wcomponents.WTemplated.getVars( self )
     vars["logo"] = ""
     if self._conf.getLogo():
         vars["logo"] = "<img src=\"%s\" alt=\"%s\" border=\"0\">"%(vars["logoURL"], self._conf.getTitle())
     vars["confTitle"] = self._conf.getTitle()
     vars["displayURL"] = urlHandlers.UHConferenceDisplay.getURL(self._conf)
     vars["imgConferenceRoom"] = Config.getInstance().getSystemIconURL( "conferenceRoom" )
     #################################
     # Fermi timezone awareness      #
     #################################
     vars["confDateInterval"] = i18nformat("""_("from") %s _("to") %s""")%(format_date(self._conf.getStartDate(), format='long'), format_date(self._conf.getEndDate(), format='long'))
     if self._conf.getStartDate().strftime("%d%B%Y") == \
             self._conf.getEndDate().strftime("%d%B%Y"):
         vars["confDateInterval"] = format_date(self._conf.getStartDate(), format='long')
     elif self._conf.getStartDate().month == self._conf.getEndDate().month:
         vars["confDateInterval"] = "%s-%s %s"%(self._conf.getStartDate().day, self._conf.getEndDate().day, format_date(self._conf.getStartDate(), format='MMMM yyyy'))
     #################################
     # Fermi timezone awareness(end) #
     #################################
     vars["body"] = self._body
     vars["confLocation"] = ""
     if self._conf.getLocationList():
         vars["confLocation"] =  self._conf.getLocationList()[0].getName()
         vars["supportEmail"] = ""
     if self._conf.getSupportInfo().hasEmail():
         mailto = quoteattr("""mailto:%s?subject=%s"""%(self._conf.getSupportInfo().getEmail(), urllib.quote( self._conf.getTitle() ) ))
         vars["supportEmail"] =  _("""<a href=%s class="confSupportEmail"><img src="%s" border="0" alt="email"> %s</a>""")%(mailto,
                                                     Config.getInstance().getSystemIconURL("mail"),
                                                     self._conf.getSupportInfo().getCaption())
     format = displayMgr.ConfDisplayMgrRegistery().getDisplayMgr(self._conf).getFormat()
     vars["bgColorCode"] = format.getFormatOption("titleBgColor")["code"]
     vars["textColorCode"] = format.getFormatOption("titleTextColor")["code"]
     return vars
Esempio n. 26
0
    def _process_POST(self):
        if User.query.has_rows():
            return redirect(url_for_index())
        setup_form = BootstrapForm(request.form)
        if not setup_form.validate():
            flash(_("Some fields are invalid. Please, correct them and submit the form again."), 'error')
            return redirect(url_for('bootstrap.index'))

        # Creating new user
        user = User()
        user.first_name = to_unicode(setup_form.first_name.data)
        user.last_name = to_unicode(setup_form.last_name.data)
        user.affiliation = to_unicode(setup_form.affiliation.data)
        user.email = to_unicode(setup_form.email.data)
        user.is_admin = True

        identity = Identity(provider='indico', identifier=setup_form.username.data, password=setup_form.password.data)
        user.identities.add(identity)

        db.session.add(user)
        db.session.flush()

        user.settings.set('timezone', Config.getInstance().getDefaultTimezone())
        user.settings.set('lang', session.lang or Config.getInstance().getDefaultLocale())

        login_user(user, identity)
        full_name = user.full_name  # needed after the session closes

        transaction.commit()

        # Configuring server's settings
        minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
        minfo.setOrganisation(setup_form.affiliation.data)

        message = get_template_module('bootstrap/flash_messages.html').bootstrap_success(name=full_name)
        flash(Markup(message), 'success')

        # Activate instance tracking
        if setup_form.enable_tracking.data:
            contact_name = setup_form.contact_name.data
            contact_email = setup_form.contact_email.data

            try:
                register_instance(contact_name, contact_email)
            except (HTTPError, ValueError) as err:
                message = get_template_module('bootstrap/flash_messages.html').community_error(err=err)
                category = 'error'
            except Timeout:
                message = get_template_module('bootstrap/flash_messages.html').community_timeout()
                category = 'error'
            except RequestException as exc:
                message = get_template_module('bootstrap/flash_messages.html').community_exception(exc=exc)
                category = 'error'
            else:
                message = get_template_module('bootstrap/flash_messages.html').community_success()
                category = 'success'
            flash(Markup(message), category)

        return redirect(url_for_index())
Esempio n. 27
0
 def _getAnswer(self):
     self._target.getReportNumberHolder().addReportNumber(self._reportNumberSystem, self._reportNumber)
     if self._reportNumberSystem in Config.getInstance().getReportNumberSystems().keys():
         reportNumberId="s%sr%s"%(self._reportNumberSystem, self._reportNumber)
         name = Config.getInstance().getReportNumberSystems()[self._reportNumberSystem]["name"]
         return {"id":reportNumberId, "name":name , "system":self._reportNumberSystem, "number": self._reportNumber}
     else:
         return {}
Esempio n. 28
0
def smtp(disallow_emails, smtpserver):
    """Wrapper for the `smtpserver` fixture which updates the Indico config
    and disables the SMTP autofail logic for that smtp server.
    """
    old_smtp_server = Config.getInstance().getSmtpServer()
    Config.getInstance().update(SmtpServer=smtpserver.addr)
    disallow_emails.add(smtpserver.addr)  # whitelist our smtp server
    yield smtpserver
    Config.getInstance().update(SmtpServer=old_smtp_server)
Esempio n. 29
0
    def __init__(self, plugin_name, plugin_dir, url_path):
        config = Config.getInstance()
        url_base_path = urlparse(config.getBaseURL()).path
        output_dir = os.path.join(config.getHtdocsDir(), 'static', 'assets', 'plugins', plugin_name)
        url = '{0}/static/assets/plugins/{1}'.format(url_base_path, url_path)

        super(PluginEnvironment, self).__init__(output_dir, url)
        self.debug = Config.getInstance().getDebug()
        self.append_path(os.path.join(plugin_dir, 'htdocs'), url=os.path.join(url_base_path, url_path))
Esempio n. 30
0
    def create(self, static_site_id):
        config = Config.getInstance()
        self._fileHandler = ZIPFileHandler()

        # create the home page html
        self._create_home()

        # Create main and static folders
        self._mainPath = self._normalize_path(u"OfflineWebsite-{}".format(self._conf.getTitle().decode("utf-8")))
        self._fileHandler.addDir(self._mainPath)
        self._staticPath = os.path.join(self._mainPath, "static")
        self._fileHandler.addDir(self._staticPath)
        # Add i18n js
        self._addFolderFromSrc(
            os.path.join(self._staticPath, "js", "indico", "i18n"),
            os.path.join(config.getHtdocsDir(), "js", "indico", "i18n"),
        )
        # Add system icons (not referenced in HTML/CSS)
        for icon in Config.getInstance().getSystemIcons().itervalues():
            self._addFileFromSrc(
                os.path.join(self._staticPath, "images", icon), os.path.join(config.getHtdocsDir(), "images", icon)
            )
        # IE compat files (in conditional comments so BS doesn't see them)
        for path in ie_compatibility.urls():
            self._addFileFromSrc(
                os.path.join(self._staticPath, path.lstrip("/")), os.path.join(config.getHtdocsDir(), path.lstrip("/"))
            )

        # Getting all materials, static files (css, images, js and vars.js.tpl)
        self._getAllMaterial()
        self._html = self._get_static_files(self._html)

        # Specific changes
        self._create_other_pages()

        # Retrieve files that were not available in the file system (e.e. js/css from plugins)
        self._get_failed_paths()
        self._failed_paths = set()

        # Retrieve files referenced in CSS files
        self._get_css_refs()

        # A custom event CSS might reference an uploaded image so we need to check for failed paths again
        self._get_failed_paths()

        # Creating ConferenceDisplay.html file
        conferenceDisplayPath = os.path.join(self._mainPath, urlHandlers.UHConferenceDisplay.getStaticURL())
        self._fileHandler.addNewFile(conferenceDisplayPath, self._html)

        # Creating index.html file
        self._fileHandler.addNewFile(
            "index.html", '<meta http-equiv="Refresh" content="0; url=%s">' % conferenceDisplayPath
        )

        self._fileHandler.close()
        return self._save_file(self._fileHandler.getPath(), static_site_id)
Esempio n. 31
0
    def __init__(self, user, role, contribution):
        conference = contribution.event_new.as_legacy
        GenericNotification.__init__(self)
        self.setFromAddr("Indico <%s>" % Config.getInstance().getNoReplyEmail())
        self.setToList([user.email])
        self.setSubject("""An author has submitted a paper for "%s" """%  conference.getTitle())

        if role == 'Referee':
            url = url_for('event_mgmt.confListContribToJudge', conference, _external=True)
        elif role == 'Layout Reviewer':
            url = url_for('event_mgmt.confListContribToJudge-asEditor', conference, _external=True)
        elif role == 'Content Reviewer':
            url = url_for('event_mgmt.confListContribToJudge-asReviewer', conference, _external=True)

        self.setBody("""Dear %s,

An author has submitted a paper entitled "%s" (id: %s) for the conference "%s". You can now start the reviewing process as a %s:

%s

Kind regards,
Indico on behalf of "%s"
""" % ( user.full_name, contribution.title, str(contribution.friendly_id), conference.getTitle(), role, url, conference.getTitle()))
Esempio n. 32
0
    def __init__(self, post_url=None, max_file_size=None, max_files=10, add_remove_links=True, accepted_file_types=None,
                 param_name='file', submit_if_empty=True, submit_form=False, handle_flashes=False):
        super(DropzoneWidget, self).__init__('forms/dropzone_widget.html')

        config = Config.getInstance()

        if max_file_size is None:
            max_file_size = min(config.getMaxUploadFileSize() or 10240,
                                config.getMaxUploadFilesTotalSize() or 10240)  # in MB

        self.options = {
            'url': post_url,
            'uploadMultiple': max_files > 1,
            'maxFilesize': max_file_size,
            'maxFiles': max_files,
            'addRemoveLinks': add_remove_links,
            'acceptedFiles': accepted_file_types,
            'paramName': param_name,
            'submitForm': submit_form,
            'submitIfEmpty': submit_if_empty,
            'parallelUploads': max_files,
            'handleFlashes': handle_flashes
        }
Esempio n. 33
0
class TestMaterialRepository(IndicoTestCase):
    """
    Tests the basic functionalities of the MaterialLocalRepository file
    repository.
    """

    _requires = ["db.DummyUser"]

    def setUp(self):
        super(TestMaterialRepository, self).setUp()
        self._archivePath = os.path.join(os.getcwd(), "tmpArchive")
        #create a directory where the archive will be set up
        try:
            os.mkdir(self._archivePath)
        except OSError, e:
            #print e
            pass
        #the MaterialLocalRepository takes the repository base path from
        #   the system configuration so we have to set it up to the new dir
        from indico.core.config import Config
        cfg = Config.getInstance()
        #we overrride the system repository path with the temp one
        cfg._archivePath = self._archivePath
Esempio n. 34
0
def _setup(args):

    cfg = Config.getInstance()

    # logging setup
    handler = logging.handlers.TimedRotatingFileHandler(
        os.path.join(cfg.getLogDir(), 'scheduler.log'), 'midnight')
    handler.setFormatter(
        logging.Formatter(
            "%(asctime)s %(process)s %(name)s: %(levelname)-8s %(message)s"))

    if 'log' not in args.__dict__:
        args.log = 'INFO'

    level = getattr(logging, args.log)

    root_logger = logging.getLogger('')
    root_logger.addHandler(handler)
    root_logger.setLevel(level)

    mp_logger = multiprocessing.get_logger()
    mp_logger.setLevel(level)
    mp_logger.addHandler(handler)
Esempio n. 35
0
def get_storage(backend_name):
    """Returns an FS object for the given backend.

    The backend must be defined in the StorageBackends dict in the
    indico config.  Once a backend has been used it is assumed to
    stay there forever or at least as long as it is referenced
    somewhere.

    Each backend definition uses the ``name:data`` notation, e.g.
    ``fs:/some/folder/`` or ``foo:host=foo.host,token=secret``.
    """
    try:
        definition = Config.getInstance().getStorageBackends()[backend_name]
    except KeyError:
        raise RuntimeError(
            'Storage backend does not exist: {}'.format(backend_name))
    name, data = definition.split(':', 1)
    try:
        backend = get_storage_backends()[name]
    except KeyError:
        raise RuntimeError('Storage backend {} has invalid type {}'.format(
            backend_name, name))
    return backend(data)
Esempio n. 36
0
    def _getIcalExportParams(self, user, url, params=None):
        apiMode = api_settings.get('security_mode')
        apiKey = user.api_key if user else None

        urls = generate_public_auth_request(apiKey, url, params)
        tpl = get_template_module('api/_messages.html')

        return {
            'currentUser': user,
            'icsIconURL':
            str(Config.getInstance().getSystemIconURL("ical_grey")),
            'apiMode': apiMode,
            'signingEnabled': apiMode
            in {APIMode.SIGNED, APIMode.ONLYKEY_SIGNED, APIMode.ALL_SIGNED},
            'persistentAllowed': api_settings.get('allow_persistent'),
            'requestURLs': urls,
            'persistentUserEnabled':
            apiKey.is_persistent_allowed if apiKey else False,
            'apiActive': apiKey is not None,
            'userLogged': user is not None,
            'apiKeyUserAgreement': tpl.get_ical_api_key_msg(),
            'apiPersistentUserAgreement': tpl.get_ical_persistent_msg()
        }
Esempio n. 37
0
def configure_multipass(app):
    cfg = Config.getInstance()
    app.config['MULTIPASS_AUTH_PROVIDERS'] = cfg.getAuthProviders()
    app.config['MULTIPASS_IDENTITY_PROVIDERS'] = cfg.getIdentityProviders()
    app.config['MULTIPASS_PROVIDER_MAP'] = cfg.getProviderMap() or {
        x: x
        for x in cfg.getAuthProviders()
    }
    if 'indico' in app.config[
            'MULTIPASS_AUTH_PROVIDERS'] or 'indico' in app.config[
                'MULTIPASS_IDENTITY_PROVIDERS']:
        raise ValueError(
            'The name `indico` is reserved and cannot be used as an Auth/Identity provider name.'
        )
    if cfg.getLocalIdentities():
        configure_multipass_local(app)
    app.config['MULTIPASS_IDENTITY_INFO_KEYS'] = {
        'first_name', 'last_name', 'email', 'affiliation', 'phone', 'address'
    }
    app.config['MULTIPASS_LOGIN_ENDPOINT'] = 'auth.login'
    app.config['MULTIPASS_LOGIN_URLS'] = None  # registered in a blueprint
    app.config['MULTIPASS_SUCCESS_ENDPOINT'] = 'misc.index'
    app.config['MULTIPASS_FAILURE_MESSAGE'] = _(u'Login failed: {error}')
Esempio n. 38
0
 def _process(self):
     form = CephalopodForm(obj=FormDefaults(
         **cephalopod_settings.get_all()))
     if form.validate_on_submit():
         return self._process_form(form)
     config = Config.getInstance()
     hub_url = url_join(
         config.getCommunityHubURL(),
         'api/instance/{}'.format(cephalopod_settings.get('uuid')))
     cephalopod_settings.set('show_migration_message', False)
     return WPCephalopod.render_template(
         'cephalopod.html',
         'cephalopod',
         affiliation=core_settings.get('site_organization'),
         enabled=cephalopod_settings.get('joined'),
         form=form,
         indico_version=indico.__version__,
         instance_url=config.getBaseURL(),
         language=config.getDefaultLocale(),
         operating_system=get_os(),
         postgres_version=get_postgres_version(),
         python_version=platform.python_version(),
         hub_url=hub_url)
Esempio n. 39
0
    def _create_user(self, form, handler, pending_user):
        data = form.data
        if pending_user:
            user = pending_user
            user.is_pending = False
        else:
            user = User()
        form.populate_obj(user, skip={'email'})
        if form.email.data in user.secondary_emails:
            # This can happen if there's a pending user who has a secondary email
            # for some weird reason which should now become the primary email...
            user.make_email_primary(form.email.data)
        else:
            user.email = form.email.data
        identity = handler.create_identity(data)
        user.identities.add(identity)
        user.secondary_emails |= handler.get_all_emails(form) - {user.email}
        user.favorite_users.add(user)
        db.session.add(user)
        minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
        timezone = session.timezone
        if timezone == 'LOCAL':
            timezone = Config.getInstance().getDefaultTimezone()
        user.settings.set('timezone', timezone)
        user.settings.set('lang', session.lang or minfo.getLang())
        handler.update_user(user, form)
        db.session.flush()

        # notify everyone of user creation
        signals.users.registered.send(user)

        login_user(user, identity)
        msg = _('You have sucessfully registered your Indico profile. '
                'Check <a href="{url}">your profile</a> for further details and settings.')
        flash(Markup(msg).format(url=url_for('users.user_profile')), 'success')
        db.session.flush()
        return handler.redirect_success()
Esempio n. 40
0
def convertLinkedTo(dbi, prevVersion):
    """Convert Avatar.linkedTo structure to use OOTreeSets
       and import linkedTo information into Redis (if enabled)"""
    print 'Note: Some links might point to broken objects which will be skipped automatically.'

    use_redis = Config.getInstance().getRedisConnectionURL()

    if use_redis:
        pipe = redis_client.pipeline(transaction=False)

    for i, avatar in enumerate(AvatarHolder()._getIdx().itervalues()):
        avatar.updateLinkedTo()  # just in case some avatars do not have all fields
        linkedTo = avatar.linkedTo
        avatar.resetLinkedTo()  # nuke old links
        for field, data in avatar.linkedToMap.iteritems():
            for role in data['roles']:
                if not linkedTo[field][role]:
                    continue
                todo = set(linkedTo[field][role])
                # We have broken objects in the database which will fail in the getConference() call. If the current
                # object type has such a method call it on each object and skip it in case it raises an AttributeError
                if hasattr(linkedTo[field][role][0], 'getConference'):
                    for obj in linkedTo[field][role]:
                        try:
                            obj.getConference()
                        except AttributeError, e:
                            print '  \tSkipping broken object in %s/%s/%s: %r' % (avatar.getId(), field, role, obj)
                            todo.remove(obj)
                avatar.linkedTo[field][role].update(todo)
        if use_redis:
            avatar_links.init_links(avatar, client=pipe)
        if i % 1000 == 0:
            if use_redis:
                pipe.execute()
            dbi.commit()
        print '\r  %d' % i,
        sys.stdout.flush()
Esempio n. 41
0
    def _getHTMLHeader(self):
        from MaKaC.webinterface.pages.conferences import WPConfSignIn
        from MaKaC.webinterface.pages.signIn import WPSignIn
        from MaKaC.webinterface.pages.registrationForm import WPRegistrationFormSignIn
        from MaKaC.webinterface.rh.base import RHModificationBaseProtected
        from MaKaC.webinterface.rh.admins import RHAdminBase

        area = ""
        if isinstance(self._rh, RHModificationBaseProtected):
            area = i18nformat(""" - _("Management area")""")
        elif isinstance(self._rh, RHAdminBase):
            area = i18nformat(""" - _("Administrator area")""")

        info = HelperMaKaCInfo().getMaKaCInfoInstance()

        return wcomponents.WHTMLHeader().getHTML({
            "area":
            area,
            "baseurl":
            self._getBaseURL(),
            "conf":
            Config.getInstance(),
            "page":
            self,
            "extraCSS":
            map(self._fix_path, self.getCSSFiles()),
            "extraJSFiles":
            map(self._fix_path, self.getJSFiles()),
            "extraJS":
            self._extraJS,
            "language":
            session.lang,
            "social":
            info.getSocialAppConfig(),
            "assets":
            self._asset_env
        })
Esempio n. 42
0
def sync_instance(contact, email):
    contact = contact or cephalopod_settings.get('contact_name')
    email = email or cephalopod_settings.get('contact_email')
    # registration needed if the instance does not have a uuid
    if not cephalopod_settings.get('uuid'):
        logger.warn('unable to synchronise: missing uuid, registering the server instead')
        register_instance(contact, email)
        return

    payload = {'enabled': True,
               'url': Config.getInstance().getBaseURL(),
               'contact': contact,
               'email': email,
               'organisation': core_settings.get('site_organization')}
    url = url_join(_get_url(), cephalopod_settings.get('uuid'))
    response = requests.patch(url, data=json.dumps(payload), headers=HEADERS, timeout=TIMEOUT)
    try:
        response.raise_for_status()
    except HTTPError as err:
        if err.response.status_code == 404:
            logger.warn('unable to synchronise: the server was not registered, registering the server now')
            register_instance(contact, email)
        else:
            logger.error('failed to synchronise the server with the community hub, got: %s', err.message)
            raise
    except Timeout:
        logger.error('failed to synchronise: timeout while contacting the community hub')
        raise
    except RequestException as err:
        logger.error('unexpected exception while synchronizing the server with the Community Hub: %s', err.message)
        raise
    else:
        cephalopod_settings.set_multi({
            'joined': True,
            'contact_name': payload['contact'],
            'contact_email': payload['email']})
        logger.info('successfully synchronized the server with the community hub')
Esempio n. 43
0
    def setTemplate(self,
                    name,
                    description,
                    format,
                    fd,
                    id,
                    extension=".template"):
        """ Stores a template.
            There can be 1 template for any format.
        """

        cfg = Config.getInstance()
        tempPath = cfg.getUploadedFilesTempDir()
        tempFileName = tempfile.mkstemp(suffix="MaKaC.tmp", dir=tempPath)[1]
        f = open(tempFileName, "wb")
        f.write(fd.read())
        f.close()

        #id = self.getNewTemplateId()

        fileName = "Contribution_template_" + id + "_c" + self._conference.id + extension

        file = conference.LocalFile()
        file.setName(fileName)
        file.setDescription("Paper reviewing template with id " + id +
                            "with format: " + format + " of the conference " +
                            self._conference.id)
        file.setFileName(fileName)

        file.setFilePath(tempFileName)
        file.setOwner(self._conference)
        file.setId(fileName)
        file.archive(self._conference._getRepository())

        self._templates[id] = Template(id, self._conference, name, description,
                                       format, file)
        self.notifyModification()
Esempio n. 44
0
 def default_settings(self):
     return dict(
         VCPluginMixin.default_settings,
         **{
             'support_email':
             Config.getInstance().getSupportEmail(),
             'username':
             '******',
             'password':
             None,
             'admin_api_wsdl':
             'https://yourvidyoportal/services/v1_1/VidyoPortalAdminService?wsdl',
             'user_api_wsdl':
             'https://yourvidyoportal/services/v1_1/VidyoPortalUserService?wsdl',
             'indico_room_prefix':
             10,
             'room_group_name':
             'Indico',
             # we skip identity providers in the default list if they don't support get_identity.
             # these providers (local accounts, oauth) are unlikely be the correct ones to integrate
             # with the vidyo infrastructure.
             'authenticators':
             ', '.join(p.name
                       for p in multipass.identity_providers.itervalues()
                       if p.supports_get),
             'num_days_old':
             365,
             'max_rooms_warning':
             5000,
             'vidyo_phone_link':
             None,
             'creation_email_footer':
             None,
             'client_chooser_url':
             None
         })
Esempio n. 45
0
def shell_cmd(verbose, with_req_context):
    try:
        from IPython.terminal.ipapp import TerminalIPythonApp
    except ImportError:
        click.echo(cformat('%{red!}You need to `pip install ipython` to use the Indico shell'))
        sys.exit(1)

    current_app.config['REPL'] = True  # disables e.g. memoize_request
    request_stats_request_started()
    context, info = _make_shell_context()
    banner = cformat('%{yellow!}Indico v{} is ready for your commands').format(indico.__version__)
    if verbose:
        banner = '\n'.join(info + ['', banner])
    ctx = current_app.make_shell_context()
    ctx.update(context)
    clearCache()
    stack = ExitStack()
    if with_req_context:
        stack.enter_context(current_app.test_request_context(base_url=Config.getInstance().getBaseURL()))
    with stack:
        ipython_app = TerminalIPythonApp.instance(user_ns=ctx, display_banner=False)
        ipython_app.initialize(argv=[])
        ipython_app.shell.show_banner(banner)
        ipython_app.start()
Esempio n. 46
0
def format_time(t,
                format='short',
                locale=None,
                timezone=None,
                server_tz=False):
    """
    Basically a wrapper around Babel's own format_time
    """
    inject_unicode = True
    if format == 'code':
        format = 'HH:mm'
        inject_unicode = False
    if not locale:
        locale = get_current_locale()
    if not timezone and t.tzinfo:
        timezone = DisplayTZ().getDisplayTZ()
    elif server_tz:
        timezone = Config.getInstance().getDefaultTimezone()
    if timezone:
        timezone = get_timezone(timezone)

    rv = _format_time(t, format=format, locale=locale, tzinfo=timezone)
    return inject_unicode_debug(
        rv, 2).encode('utf-8') if inject_unicode else rv.encode('utf-8')
Esempio n. 47
0
def _sidemenu_items(sender, event, **kwargs):

    # Some legacy handling of menu items
    # Once those parts are modularized, we will be able to include them
    # conditionally from their respective modules.

    can_modify = event.can_manage(session.user)
    rb_active = Config.getInstance().getIsRoomBookingActive()

    event_type = event.as_legacy.getType()
    is_conference = event_type == 'conference'
    paper_review = event.as_legacy.getConfPaperReview()
    is_review_staff = paper_review.isInReviewingTeam(session.avatar)

    if can_modify:
        yield SideMenuItem('general', _('General settings'),
                           url_for('event_mgmt.conferenceModification', event),
                           90,
                           icon='settings')
        if rb_active:
            yield SideMenuItem('room_booking', _('Room Booking'),
                               url_for('event_mgmt.rooms_booking_list', event),
                               50,
                               icon='location')
    if is_conference:
        if can_modify or is_review_staff:
            yield SideMenuItem('paper_reviewing', _('Paper Reviewing'),
                               url_for('event_mgmt.confModifReviewing-access', event),
                               section='organization')

    if can_modify:
        yield SideMenuItem('utilities', _('Utilities'),
                           url_for('event_mgmt.confModifTools', event),
                           section='advanced')
        yield SideMenuItem('protection', _('Protection'), url_for('event_management.protection', event),
                           60, icon='shield')
Esempio n. 48
0
    def _getIcalExportParams(self, user, url, params={}):
        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
        apiMode = minfo.getAPIMode()
        apiKey = user.getAPIKey() if user else None

        urls = generate_public_auth_request(
            apiMode, apiKey, url, params,
            minfo.isAPIPersistentAllowed()
            and (apiKey.isPersistentAllowed() if apiKey else False),
            minfo.isAPIHTTPSRequired())

        return {
            'currentUser':
            user,
            'icsIconURL':
            str(Config.getInstance().getSystemIconURL("ical_grey")),
            'apiMode':
            apiMode,
            'signingEnabled':
            apiMode
            in (API_MODE_SIGNED, API_MODE_ONLYKEY_SIGNED, API_MODE_ALL_SIGNED),
            'persistentAllowed':
            minfo.isAPIPersistentAllowed(),
            'requestURLs':
            urls,
            'persistentUserEnabled':
            apiKey.isPersistentAllowed() if apiKey else False,
            'apiActive':
            apiKey != None,
            'userLogged':
            user != None,
            'apiKeyUserAgreement':
            minfo.getAPIKeyUserAgreement(),
            'apiPersistentUserAgreement':
            minfo.getAPIPersistentUserAgreement()
        }
Esempio n. 49
0
 def check(self):
     errors = []
     if self.title.strip() == "":
         errors.append(_("Abstract title cannot be empty"))
     for f in self._afm.getFields():
         value = self._otherFields.get(f.getId(), "")
         errors += f.check(value)
     if not self.origin == "management":
         if not self._prAuthorsListParam:
             errors.append(
                 _("No primary author has been specified. You must define at least one primary author"
                   ))
         if not self._checkSpeaker() and self._absMgr.showSelectAsSpeaker(
         ) and self._absMgr.isSelectSpeakerMandatory():
             errors.append(_("At least one presenter must be specified"))
     if not self.tracks and self._absMgr.areTracksMandatory():
         # check if there are tracks, otherwise the user cannot select at least one
         if len(self._absMgr.getConference().getTrackList()) != 0:
             errors.append(_("At least one track must be seleted"))
     if self._hasExceededTotalSize():
         errors.append(
             _("The maximum size allowed for the attachments (%sMB) has been exceeded."
               ) % Config.getInstance().getMaxUploadFilesTotalSize())
     return errors
Esempio n. 50
0
 def _get_static_files(self, html):
     config = Config.getInstance()
     soup = BeautifulSoup(html)
     scripts = set(
         _fix_url_path(x['src']) for x in soup.select('script[src]'))
     styles = set(
         _fix_url_path(x['href'])
         for x in soup.select('link[rel="stylesheet"]'))
     for path in itertools.chain(scripts, styles):
         src_path = os.path.join(config.getHtdocsDir(), path)
         dst_path = os.path.join(self._staticPath, path)
         if path in styles:
             self._css_files.add(path)
         if not os.path.isfile(src_path):
             self._failed_paths.add(path)
         elif path not in styles:
             self._addFileFromSrc(dst_path, src_path)
     for script in soup.select('script[src]'):
         script['src'] = os.path.join('static',
                                      _fix_url_path(script['src']))
     for style in soup.select('link[rel="stylesheet"]'):
         style['href'] = os.path.join('static',
                                      _fix_url_path(style['href']))
     return str(soup)
Esempio n. 51
0
    def _process_GET(self):
        defaults = FormDefaults(**cephalopod_settings.get_all())
        form = CephalopodForm(request.form, obj=defaults)

        enabled = cephalopod_settings.get('joined')
        config = Config.getInstance()
        instance_url = config.getBaseURL()
        language = config.getDefaultLocale()
        tracker_url = urljoin(
            config.getTrackerURL(),
            'api/instance/{}'.format(cephalopod_settings.get('uuid')))
        return WPCephalopod.render_template(
            'cephalopod.html',
            'cephalopod',
            affiliation=core_settings.get('site_organization'),
            enabled=enabled,
            form=form,
            indico_version=indico.__version__,
            instance_url=instance_url,
            language=language,
            operating_system=get_os(),
            postgres_version=get_postgres_version(),
            python_version=platform.python_version(),
            tracker_url=tracker_url)
Esempio n. 52
0
    def __init__(self, booking, oldOwner):
        VidyoOwnerNotificationBase.__init__(self)
        self._owner = oldOwner
        self.setFromAddr("Indico Mailer <%s>" %
                         Config.getInstance().getSupportEmail())
        self.setContentType("text/html")

        event = booking.getConference()

        self.setToList([oldOwner.getEmail()])

        self.setSubject(
            """[Indico] You are no longer the owner of a Vidyo public room attached to the event: %s"""
            % event.getTitle())

        self.setBody("""Dear %s%s,<br />
<br />
This is an automatic email to inform you that you are no longer the owner of the Vidyo room with name "%s" in the event <a href="%s">%s</a>. The new owner is %s.<br />
<br />
Thank you for using our system.<br />
""" % (self._getOwnerTitleText(), oldOwner.getStraightFullName(),
        booking.getBookingParamByName("roomName"),
        urlHandlers.UHConferenceDisplay.getURL(event), event.getTitle(),
        booking.getOwner()["name"]))
Esempio n. 53
0
    def __init__(self, user, role, contribution):
        GenericNotification.__init__(self)
        conference = contribution.event_new.as_legacy
        self.setFromAddr("Indico <%s>" % Config.getInstance().getNoReplyEmail())
        self.setToList([user.email])
        self.setSubject("""You have been chosen as a %s for "%s" """% (role, conference.getTitle()))

        if role == 'Referee':
            url = url_for('event_mgmt.confListContribToJudge', conference, _external=True)
        elif role == 'Layout Reviewer':
            url = url_for('event_mgmt.confListContribToJudge-asEditor', conference, _external=True)
        elif role == 'Content Reviewer':
            url = url_for('event_mgmt.confListContribToJudge-asReviewer', conference, _external=True)

        self.setBody("""Dear %s,

You have been chosen as a %s for the paper entitled "%s" (id: %s) for the conference "%s". Please find the %s utilities here:

%s

Kind regards,
Indico on behalf of "%s"
""" % ( user.full_name, role, contribution.title, str(contribution.friendly_id),
        conference.getTitle(), role, url, conference.getTitle()))
Esempio n. 54
0
    def __init__(self, user, judgement, contribution):
        GenericNotification.__init__(self)
        conference = contribution.event_new.as_legacy
        self.setFromAddr("Indico <%s>" % Config.getInstance().getNoReplyEmail())
        self.setToList([user.email])
        self.setBCCList([judgement.getAuthor().getEmail()])
        if isinstance(judgement, RefereeJudgement):
            typeR = "Referee"
        elif isinstance(judgement, EditorJudgement):
            typeR = "Layout Reviewer"
        elif isinstance(judgement, ReviewerJudgement):
            typeR = "Content Reviewer"
        self.setSubject(""""%s" has been put back into reviewing by the %s """ % (contribution.title, typeR))
        self.setBody("""Dear %s,

Your paper entitled  "%s" (id: %s) submitted for "%s" has been put back into reviewing by the assigned %s:

%s

Kind regards,
Indico on behalf of "%s"
""" % (user.full_name, contribution.title, str(contribution.friendly_id),
       conference.getTitle(), typeR, url_for('contributions.display_contribution', contribution, _external=True),
       conference.getTitle()))
Esempio n. 55
0
 def getVars(self):
     vars = wcomponents.WTemplated.getVars(self)
     minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
     vars["title"] = minfo.getTitle()
     vars["organisation"] = minfo.getOrganisation()
     vars['supportEmail'] = Config.getInstance().getSupportEmail()
     vars['publicSupportEmail'] = Config.getInstance(
     ).getPublicSupportEmail()
     vars['noReplyEmail'] = Config.getInstance().getNoReplyEmail()
     vars["lang"] = minfo.getLang()
     vars["address"] = ""
     if minfo.getCity() != "":
         vars["address"] = minfo.getCity()
     if minfo.getCountry() != "":
         if vars["address"] != "":
             vars["address"] = "%s (%s)" % (vars["address"],
                                            minfo.getCountry())
         else:
             vars["address"] = "%s" % minfo.getCountry()
     try:
         vars["timezone"] = minfo.getTimezone()
     except:
         vars["timezone"] = 'UTC'
     vars["systemIconAdmins"] = Config.getInstance().getSystemIconURL(
         "admin")
     iconDisabled = str(
         Config.getInstance().getSystemIconURL("disabledSection"))
     iconEnabled = str(
         Config.getInstance().getSystemIconURL("enabledSection"))
     url = urlHandlers.UHAdminSwitchNewsActive.getURL()
     icon = iconEnabled if minfo.isNewsActive() else iconDisabled
     vars["features"] = i18nformat(
         """<a href="%s"><img src="%s" border="0" style="float:left; padding-right: 5px">_("News Pages")</a>"""
     ) % (url, icon)
     vars["administrators"] = fossilize(
         [u.as_avatar for u in User.find(is_admin=True)])
     return vars
Esempio n. 56
0
                 'js/lib/angular-resource.js',
                 'js/lib/angular-sanitize.js',
                 'js/lib/sortable.js',
                 'js/indico/angular/app.js',
                 'js/indico/angular/directives.js',
                 'js/indico/angular/filters.js',
                 'js/indico/angular/services.js',
                 filters='rjsmin',
                 output='js/angular_%(version)s.min.js')

jquery = Bundle(*filter(None, [
    'js/lib/underscore.js', 'js/lib/jquery.js', 'js/lib/jquery.qtip.js',
    'js/jquery/jquery-ui.js', 'js/lib/jquery.multiselect.js',
    'js/lib/jquery.multiselect.filter.js',
    'js/jquery/jquery-migrate-silencer.js'
    if not Config.getInstance().getDebug() else None
] + namespace('js/jquery', 'jquery-migrate.js', 'jquery.form.js',
              'jquery.custom.js', 'jquery.daterange.js', 'jquery.dttbutton.js',
              'jquery.colorbox.js', 'jquery.menu.js', 'date.js',
              'jquery.colorpicker.js', 'jquery-extra-selectors.js',
              'jquery.typewatch.js', 'jstorage.js', 'jquery.watermark.js',
              'jquery.placeholder.js')),
                filters='rjsmin',
                output='js/jquery_code_%(version)s.min.js')

utils = Bundle('js/utils/routing.js',
               filters='rjsmin',
               output='js/utils_%(version)s.min.js')

calendar = Bundle(*namespace('js/calendar', 'calendar.js',
                             'calendar-setup.js'),
Esempio n. 57
0
 def __init__(self, XG):
     # self.categoryRoot = conference.CategoryManager().getRoot()
     self._user = accessControl.AccessWrapper()
     self._XMLGen = XG
     self._config = Config.getInstance()
     self._outGen = outputGenerator(self._user, self._XMLGen)
Esempio n. 58
0
def setup_jinja(app):
    config = Config.getInstance()
    # Unicode hack
    app.jinja_env.add_extension(EnsureUnicodeExtension)
    app.add_template_filter(EnsureUnicodeExtension.ensure_unicode)
    # Useful (Python) builtins
    app.add_template_global(dict)
    # Global functions
    app.add_template_global(url_for)
    app.add_template_global(url_for_plugin)
    app.add_template_global(url_rule_to_js)
    app.add_template_global(IndicoConfigWrapper(config), 'indico_config')
    app.add_template_global(config.getSystemIconURL, 'system_icon')
    app.add_template_global(include_css_assets)
    app.add_template_global(include_js_assets)
    app.add_template_global(include_plugin_css_assets)
    app.add_template_global(include_plugin_js_assets)
    app.add_template_global(call_template_hook, 'template_hook')
    app.add_template_global(is_single_line_field, '_is_single_line_field')
    app.add_template_global(render_field, '_render_field')
    app.add_template_global(iter_form_fields, '_iter_form_fields')
    app.add_template_global(format_currency)
    app.add_template_global(get_currency_name)
    app.add_template_global(url_for_index)
    app.add_template_global(url_for_login)
    app.add_template_global(url_for_logout)
    app.add_template_global(lambda: unicode(uuid.uuid4()), 'uuid')
    app.add_template_global(icon_from_mimetype)
    app.add_template_global(render_sidemenu)
    app.add_template_global(slugify)
    app.add_template_global(lambda: date_time_util.now_utc(False), 'now')
    app.add_template_global(render_session_bar)
    app.add_template_global(lambda: 'custom_js' in core_env, 'has_custom_js')
    app.add_template_global(lambda: 'custom_sass' in core_env,
                            'has_custom_sass')
    app.add_template_global(get_request_stats)
    # Global variables
    app.add_template_global(LocalProxy(get_current_locale), 'current_locale')
    # Useful constants
    app.add_template_global('^([0-9]|0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$',
                            name='time_regex_hhmm')  # for input[type=time]
    # Filters (indico functions returning UTF8)
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_date))
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_time))
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_datetime))
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_human_date))
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_timedelta))
    app.add_template_filter(
        EnsureUnicodeExtension.wrap_func(date_time_util.format_number))
    # Filters (new ones returning unicode)
    app.add_template_filter(date_time_util.format_human_timedelta)
    app.add_template_filter(date_time_util.format_pretty_date)
    app.add_template_filter(date_time_util.format_pretty_datetime)
    app.add_template_filter(lambda d: Markup(html_params(**d)), 'html_params')
    app.add_template_filter(underline)
    app.add_template_filter(markdown)
    app.add_template_filter(dedent)
    app.add_template_filter(natsort)
    app.add_template_filter(groupby)
    app.add_template_filter(any)
    app.add_template_filter(strip_tags)
    app.add_template_filter(alpha_enum)
    app.add_template_filter(crc32)
    app.add_template_filter(bool)
    # Tests
    app.add_template_test(
        instanceof)  # only use this test if you really have to!
    app.add_template_test(
        subclassof)  # only use this test if you really have to!
    # i18n
    app.jinja_env.add_extension('jinja2.ext.i18n')
    app.jinja_env.install_gettext_callables(gettext_context, ngettext_context,
                                            True)
    # webassets
    app.jinja_env.add_extension('webassets.ext.jinja2.AssetsExtension')
    app.jinja_env.assets_environment = core_env
Esempio n. 59
0
 def _getNewTempFile(self):
     cfg = Config.getInstance()
     tempPath = cfg.getUploadedFilesTempDir()
     tempFileName = tempfile.mkstemp(suffix="Indico.tmp", dir=tempPath)[1]
     return tempFileName
Esempio n. 60
0
 def __init__(self):
     self._tempFiles = {}
     self._repositoryIds = None
     self._errorList = []
     self._cfg = Config.getInstance()