コード例 #1
0
ファイル: models.py プロジェクト: sibande/humusha
    def __unicode__(self):
        word_history_cls = globals()['Word'].__history_mapper__.class_

        word_1 = word_history_cls.query.filter_by(id=self.word_id_1)
        word_2 = word_history_cls.query.filter_by(id=self.word_id_2)

        word_1 = word_1.filter(
            word_history_cls.created<self.created+datetime.timedelta(seconds=60)
        ).order_by('word_history.created DESC').first()
        language_1 = Language.query.filter_by(id=word_1.language_id).first()
        word_2 = word_2.filter(
            word_history_cls.created<self.created+datetime.timedelta(seconds=60)
        ).order_by('word_history.created DESC').first()
        language_2 = Language.query.filter_by(id=word_2.language_id).first()
        # I don't expect the part ID to change
        relation = Relation.query.filter_by(id=self.relation_id).first()

        markup = Markup(
            u'<a href="{0}">{1}</a> <em>{2} of</em> <a href="{3}">{4}</a>'
        )
        markup = markup.format(
            url_for('words.view', word_data=word_1.word, language_code=language_1.code),
            word_1.word, relation.part.label.lower(),
            url_for('words.view', word_data=word_2.word, language_code=language_2.code),
            word_2.word
        )
        return markup
コード例 #2
0
    def toRSSItem(self):
        title = self.repo.tagname

        if self.message and len(self.message) > 50: title += " - " + str(Markup.escape(self.message[:50])) + "..."
        elif self.message: title += " - " + str(Markup.escape(self.message))

        if self.dbkeywords: title += " - " + ",".join(self.dbkeywords)
        
        description  = "<pre>"
        description += str(self.getpprint(True))
        description += "</pre>"
        
	if type(title) != unicode:
		title = unicode(title, 'utf-8')
	if type(description) != unicode:
		description = unicode(description, 'utf-8')
        title = unicodedata.normalize('NFKD', title).encode('ascii', 'ignore')
        description = unicodedata.normalize('NFKD', description).encode('ascii', 'ignore')

        guid = Config.rooturl + "/commit/" + self.repo.tagname + "/" + self.uniqueid
        link = ''
        if self.repo.viewlink:
            link = self.repo.viewlink.replace('%ID', self.uniqueid)
        else:
            link = guid

        item = RSSItem(
            title = title,
            link = link,
            description = description,
            guid = Guid(guid, isPermaLink=0),
            pubDate = unixToDatetime(self.date)
            )
        return item
コード例 #3
0
ファイル: feeds.py プロジェクト: matze/sigal
def generate_feed(gallery, medias, feed_type=None, feed_url='', nb_items=0):
    root_album = gallery.albums['.']
    cls = Rss201rev2Feed if feed_type == 'rss' else Atom1Feed
    feed = cls(
        title=Markup.escape(root_album.title),
        link='/',
        feed_url=feed_url,
        description=Markup.escape(root_album.description).striptags()
    )

    nb_medias = len(medias)
    nb_items = min(nb_items, nb_medias) if nb_items > 0 else nb_medias

    for item in medias[:nb_items]:
        feed.add_item(
            title=Markup.escape(item.title or item.url),
            link='%s/#%s' % (item.path, item.url),
            # unique_id='tag:%s,%s:%s' % (urlparse(link).netloc,
            #                             item.date.date(),
            #                             urlparse(link).path.lstrip('/')),
            description='<img src="%s/%s" />' % (item.path, item.thumbnail),
            # categories=item.tags if hasattr(item, 'tags') else None,
            author_name=getattr(item, 'author', ''),
            pubdate=item.date or datetime.now(),
        )

    output_file = os.path.join(root_album.dst_path, feed_url.split('/')[-1])
    logger.info('Generate %s feeds: %s', feed_type.upper(), output_file)
    encoding = 'utf-8' if not compat.PY2 else None
    with codecs.open(output_file, 'w', encoding) as f:
        feed.write(f, 'utf-8')
コード例 #4
0
ファイル: hackernewest.py プロジェクト: Khady/HackerNewest
 def get_links(self):
     """get all the news links in the page
     """
     soup = BeautifulSoup(self.page)
     vote = 0
     infos = []
     links = []
     for link in soup.find_all('a'):
         l = link['href']
         if l.startswith('vote'):
             vote = 1
         elif vote == 1:
             if l.startswith("item"):
                 l = "%s/%s" % (self.surl, l)
             infos = [Markup.escape(link.string),
                      Markup.escape(l.strip()),
                      date_internet(datetime.now())]
             time.sleep(1)
             vote = 2
         elif l.startswith('item') and vote == 2:
             infos.append("%s/%s" % (self.surl, l))
             infos.append(uuid3(NAMESPACE_DNS, infos[1]))
             links.append(infos)
             vote = 0
     return links
コード例 #5
0
ファイル: security.py プロジェクト: runt18/vim-bootstrap
    def test_markup_operations(self):
        # adding two strings should escape the unsafe one
        unsafe = '<script type="application/x-some-script">alert("foo");</script>'
        safe = Markup('<em>username</em>')
        assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe)

        # string interpolations are safe to use too
        assert Markup('<em>%s</em>') % '<bad user>' == \
               '<em>&lt;bad user&gt;</em>'
        assert Markup('<em>%(username)s</em>') % {
            'username': '******'
        } == '<em>&lt;bad user&gt;</em>'

        # an escaped object is markup too
        assert type(Markup('foo') + 'bar') is Markup

        # and it implements __html__ by returning itself
        x = Markup("foo")
        assert x.__html__() is x

        # it also knows how to treat __html__ objects
        class Foo(object):
            def __html__(self):
                return '<em>awesome</em>'
            def __unicode__(self):
                return 'awesome'
        assert Markup(Foo()) == '<em>awesome</em>'
        assert Markup('<strong>%s</strong>') % Foo() == \
               '<strong><em>awesome</em></strong>'

        # escaping and unescaping
        assert escape('"<>&\'') == '&#34;&lt;&gt;&amp;&#39;'
        assert Markup("<em>Foo &amp; Bar</em>").striptags() == "Foo & Bar"
        assert Markup("&lt;test&gt;").unescape() == "<test>"
コード例 #6
0
ファイル: utils.py プロジェクト: khertan/pelican
def slugify(value):
    """
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.

    Took from django sources.
    """
    # TODO Maybe steal again from current Django 1.5dev
    value = Markup(value).striptags()
    # value must be unicode per se
    import unicodedata
    from unidecode import unidecode

    # unidecode returns str in Py2 and 3, so in Py2 we have to make
    # it unicode again
    value = unidecode(value)
    if isinstance(value, six.binary_type):
        value = value.decode("ascii")
    # still unicode
    value = unicodedata.normalize("NFKD", value)
    value = re.sub("[^\w\s-]", "", value).strip().lower()
    value = re.sub("[-\s]+", "-", value)
    # we want only ASCII chars
    value = value.encode("ascii", "ignore")
    # but Pelican should generally use only unicode
    return value.decode("ascii")
コード例 #7
0
ファイル: utils.py プロジェクト: 52M/pelican
def slugify(value, substitutions=()):
    """
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.

    Took from Django sources.
    """
    # TODO Maybe steal again from current Django 1.5dev
    value = Markup(value).striptags()
    # value must be unicode per se
    import unicodedata
    from unidecode import unidecode
    # unidecode returns str in Py2 and 3, so in Py2 we have to make
    # it unicode again
    value = unidecode(value)
    if isinstance(value, six.binary_type):
        value = value.decode('ascii')
    # still unicode
    value = unicodedata.normalize('NFKD', value).lower()
    for src, dst in substitutions:
        value = value.replace(src.lower(), dst.lower())
    value = re.sub('[^\w\s-]', '', value).strip()
    value = re.sub('[-\s]+', '-', value)
    # we want only ASCII chars
    value = value.encode('ascii', 'ignore')
    # but Pelican should generally use only unicode
    return value.decode('ascii')
コード例 #8
0
ファイル: filters.py プロジェクト: dobtco/beacon
def newline_to_br(eval_ctx, value):
    """Replaces newline characters with <br> tags

    Adapted from http://flask.pocoo.org/snippets/28/
    """
    result = u"\n\n".join(u"<p>%s</p>" % p.replace("\n", Markup("<br>\n")) for p in PARAGRAPH.split(escape(value)))
    if eval_ctx and eval_ctx.autoescape:
        result = Markup(result)
    return result.lstrip()
コード例 #9
0
def newline_to_br(eval_ctx, value):
    '''Replaces newline characters with <br> tags

    Adapted from http://flask.pocoo.org/snippets/28/
    '''
    result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', '<br>\n') for p in PARAGRAPH.split(value))
    if eval_ctx and eval_ctx.autoescape:
        result = Markup(result)
    return result.lstrip()
コード例 #10
0
ファイル: utils.py プロジェクト: rafaelmartins/ownpaste
def error_handler(error):
    if not isinstance(error, HTTPException):
        raise error
    if request_wants_json():
        desc = error.get_description(request.environ)
        desc = Markup(desc[:desc.find('.')]).striptags()
        error_str = '%s: %s' % (error.name, desc)
        response = jsonify(status='fail', error=error_str)
        response.status_code = error.code
        return response
    return error
コード例 #11
0
ファイル: models.py プロジェクト: sibande/humusha
    def __unicode__(self):
        word_history_cls = globals()['Word'].__history_mapper__.class_

        part = Part.query.filter_by(id=self.part_id).first()
        word = word_history_cls.query.filter(word_history_cls.id==self.word_id)\
            .filter(word_history_cls.version==self.version).first()
        language = Language.query.filter(Language.id==self.language_id).first()
        
        markup = Markup(u'Added {0} to <a href="{1}">{2}</a> for translations')
        markup = markup.format(language.label, url_for(
                'words.view', word_data=word.word, language_code=language.code),
                               word.word)
        return markup 
コード例 #12
0
ファイル: install.py プロジェクト: MayankR/addons-server
def install(request):
    addon_id = request.GET.get('addon_id', None)
    if addon_id:
        try:
            addon_id = int(addon_id)
        except ValueError:
            addon_id = Markup.escape(addon_id)
    addon_key = request.GET.get('addon_key', None)
    addon_name = request.GET.get('addon_name', None)
    if addon_id in addons:
        addon = addons[addon_id]
    elif addon_key in addons:
        addon = addons[addon_key]
    elif addon_name and addon_id:
        xpi = prefix('/en-US/firefox/downloads/latest/%s') % addon_id
        icon = prefix('/en-US/firefox/images/addon_icon/%s') % addon_id
        addon = {'name': addon_name, 'xpi': xpi, 'icon': icon}
    else:
        return HttpResponseNotFound()
    addon_link = addon.get('link', None)
    if addon_link:
        return HttpResponsePermanentRedirect(addon_link)
    if 'xpi' not in addon:
        return HttpResponseNotFound()
    src = request.GET.get('src', 'installservice')
    addon['xpi'] = urlparams(addon['xpi'], src=src)
    addon_params = {'URL': addon['xpi']}
    if 'icon' in addon:
        addon_params['IconURL'] = addon['icon']
    if 'hash' in addon:
        addon_params['Hash'] = addon['hash']
    referrers = ' || '.join(addon.get('referrers', default_referrers))
    return render(request, 'services/install.html',
                  {'referrers': referrers, 'addon': addon,
                   'params': json.dumps({'name': addon_params})})
コード例 #13
0
ファイル: api.py プロジェクト: MITRECND/multiscanner
def get_notes(task_id):
    '''
    Get one or more analyst notes/comments associated with the specified task.
    '''
    task = db.get_task(task_id)
    if not task:
        abort(HTTP_NOT_FOUND)

    if 'ts' in request.args and 'uid' in request.args:
        ts = request.args.get('ts', '')
        uid = request.args.get('uid', '')
        response = handler.get_notes(task.sample_id, [ts, uid])
    else:
        response = handler.get_notes(task.sample_id)

    if not response:
        abort(HTTP_BAD_REQUEST)

    if 'hits' in response and 'hits' in response['hits']:
        response = response['hits']['hits']
    try:
        for hit in response:
            hit['_source']['text'] = Markup.escape(hit['_source']['text'])
    except Exception as e:
        # TODO: log exception
        pass
    return jsonify(response)
コード例 #14
0
ファイル: better_meta.py プロジェクト: panjiesw/blog
    def get_default_meta_description(cls, article):
        summary = Markup(article.summary).striptags()
        description = textwrap.wrap(summary, META_DESCRIPTION_LENGTH)[0]
        description = Markup.escape(description)

        if len(summary) > META_DESCRIPTION_LENGTH:
            return description + '...'
        else:
            return description
コード例 #15
0
ファイル: interop.py プロジェクト: AndrewBloody/DUBALU_SMS
 def _convert_out(v, o=None):
     if getattr(filter_func, "is_safe", False) and isinstance(o, SafeData):
         v = mark_safe(v)
     elif isinstance(o, EscapeData):
         v = mark_for_escaping(v)
     if isinstance(v, SafeData):
         return Markup(v)
     if isinstance(v, EscapeData):
         return Markup.escape(v)  # not 100% equivalent, see mod docs
     return v
コード例 #16
0
 def get_escaped_var_value(value):
     """
     Encodes XML reserved chars in value (eg. &, <, >) and also replaces
     the control chars \n and \t control chars to their ODF counterparts.
     """
     value = Markup.escape(value)
     return (
         value.replace('\n', Markup('<text:line-break/>'))
              .replace('\t', Markup('<text:tab/>'))
              .replace('\x0b', '<text:space/>')
              .replace('\x0c', '<text:space/>')
     )
コード例 #17
0
ファイル: main.py プロジェクト: Kauhsa/tsoha-toot
def tweet_content(s):
    def user_url(match):
        user_id = match.group(1)
        return Markup(u'<a href="%s">@%s</a>') % (Markup.escape(url_for('user', user_id=user_id.lower())), Markup.escape(user_id))

    def tag_url(match):
        tag_id = match.group(1)
        return Markup(u'<a href="%s">#%s</a>') % (Markup.escape(url_for('tag', tag_id=tag_id.lower())), Markup.escape(tag_id))

    content = Markup.escape(s)
    content = Markup(re.sub(r'@([a-zA-Z]+)', user_url, content))
    content = Markup(re.sub(r'(?<!&)#([a-zA-Z0-9_]+)', tag_url, content))
    return content
コード例 #18
0
ファイル: better_meta.py プロジェクト: panjiesw/blog
    def create_meta_attribute(cls, article):
        article.meta = {
            'canonical': cls.get_canonical(article),
        }

        for key in META_ATTRIBUTES:
            article_attrib = "meta_%s" % key

            if hasattr(article, article_attrib):
                meta_value = Markup.escape(getattr(article, article_attrib))
            else:
                meta_value = getattr(cls, "get_default_%s" % article_attrib)(article)

            article.meta[key] = meta_value
コード例 #19
0
    def getpprint(self, htmlize=False):
        if not self.initialized:
            raise Exception("called getpprint on unitialized Commit object")

        if htmlize:
            process = lambda x : Markup.escape(x)
        else:
            process = lambda x : x
            
        eol = "\r\n"
        s = ""
        s += "Project:\t %s%s" % (self.repo.name, eol)
        if htmlize:
            s += "Project URL:\t <a href=\"%s\">%s</a>%s" % (self.repo.url, self.repo.url, eol)
        else:
            s += "Project URL:\t %s %s" % (self.repo.url, eol)
        s += "Commit Date:\t %s (%s)%s" % (unixToGitDateFormat(self.date), self.date, eol)
        s += "Log Message:\t %s%s" % (process(self.message), eol)
        s += eol + eol
        if self.files:
            s += "Files:\t\t %s%s" % (process(self.files[0]), eol)
            for p in self.files[1:14]:
                s += "\t\t %s%s" % (process(p), eol)
            if len(self.files) > 15:
                s += "\t\t ...%s" % (eol)
        if self.base_paths:
            plural = len(self.base_paths) > 1
            s += "Base Path%s:\t %s%s" % ("s" if plural else "", process(self.base_paths[0]), eol)
            for p in self.base_paths[1:]:
                s += "\t\t %s%s" % (process(p), eol)

        s += "Keywords:\t %s%s" % (", ".join(self.keywords), eol)
        s += "ID:\t\t %s%s" % (self.uniqueid, eol)
        
        internallink = Config.rooturl + "/commit/" + self.repo.tagname + "/" + self.uniqueid
        if htmlize:
            s += "Internal:\t <a href=\"%s\">%s</a>%s" % (internallink, internallink, eol)
        else:
            s += "Internal:\t %s%s" % (internallink, eol)
        
        if self.repo.viewlink:
            externallink = self.repo.viewlink.replace('%ID', self.uniqueid)
            if htmlize:
                s += "External:\t <a href=\"%s\">%s</a>%s" % (externallink, externallink, eol)
            else:
                s += "External:\t %s%s" % (externallink, eol)
        if htmlize:
            return Markup(s)
        else:
            return s
コード例 #20
0
ファイル: extensions.py プロジェクト: niwinz/django-jinja
 def _render(self, context):
     result = {
         'filters': sorted(self.environment.filters.keys()),
         'tests': sorted(self.environment.tests.keys()),
         'context': context.get_all()
     }
     #
     # We set the depth since the intent is basically to show the top few
     # names. TODO: provide user control over this?
     #
     if sys.version_info[:2] >= (3, 4):
         text = pprint.pformat(result, depth=3, compact=True)
     else:
         text = pprint.pformat(result, depth=3)
     text = Markup.escape(text)
     return text
コード例 #21
0
ファイル: app_globals.py プロジェクト: heiths/allura
 def render(self, show_title=False, extra_css=None, closing_tag=True, tag='a', **kw):
     title = kw.get('title') or self.title
     attrs = {
         'title': title,
         'class': ' '.join(['icon', extra_css or '']).strip(),
     }
     if tag == 'a':
         attrs['href'] = '#'
     attrs.update(kw)
     attrs = ew._Jinja2Widget().j2_attrs(attrs)
     visible_title = u''
     if show_title:
         visible_title = u'&nbsp;{}'.format(Markup.escape(title))
     closing_tag = u'</{}>'.format(tag) if closing_tag else u''
     icon = u'<{} {}><i class="{}"></i>{}{}'.format(tag, attrs, self.css, visible_title, closing_tag)
     return Markup(icon)
コード例 #22
0
ファイル: views.py プロジェクト: multiparadigma/Buku
 def _list_entry(self, context, model, name):
     parsed_url = urlparse(model.url)
     netloc, scheme = parsed_url.netloc, parsed_url.scheme
     is_scheme_valid = scheme in ('http', 'https')
     tag_text = []
     tag_tmpl = '<a class="btn btn-default" href="{1}">{0}</a>'
     for tag in model.tags.split(','):
         if tag:
             tag_text.append(tag_tmpl.format(tag, url_for(
                 'bookmark.index_view', flt2_tags_contain=tag)))
     if not netloc:
         return Markup("""\
         {0.title}<br/>{2}<br/>{1}{0.description}
         """.format(
             model, ''.join(tag_text), Markup.escape(model.url)
         ))
     netloc_tmpl = '<img src="{}{}"/> '
     res = netloc_tmpl.format(
         'http://www.google.com/s2/favicons?domain=', netloc)
     title = model.title if model.title else '&lt;EMPTY TITLE&gt;'
     if is_scheme_valid:
         res += '<a href="{0.url}">{1}</a>'.format(model, title)
     else:
         res += title
     if self.url_render_mode == 'netloc':
         res += ' (<a href="{1}">{0}</a>)'.format(
             netloc,
             url_for('bookmark.index_view', flt2_url_netloc_match=netloc)
         )
     res += '<br/>'
     if not is_scheme_valid:
         res += model.url
     elif self.url_render_mode is None or self.url_render_mode == 'full':
         res += '<a href="{0.url}">{0.url}</a>'.format(model)
         res += '<br/>'
     if self.url_render_mode != 'netloc':
         res += tag_tmpl.format(
             'netloc:{}'.format(netloc),
             url_for('bookmark.index_view', flt2_url_netloc_match=netloc)
         )
     res += ''.join(tag_text)
     description = model.description
     if description:
         res += '<br/>'
         res += description.replace('\n', '<br/>')
     return Markup(res)
コード例 #23
0
ファイル: views.py プロジェクト: jniebuhr/WatchPeopleCode
def streamer_page(streamer_name, page):
    streamer = Streamer.query.filter_by(reddit_username=streamer_name).first_or_404()
    wpc_stream = streamer.streams.filter_by(type='wpc_stream').first()
    streams = streamer.streams
    if wpc_stream:
        streams = streams.filter(Stream.id != wpc_stream.id)
    streams = streams.order_by(Stream.actual_start_time.desc().nullslast()).paginate(page, per_page=5)
    info_form = EditStreamerInfoForm(prefix='info')
    title_form = EditStreamTitleForm(prefix='title')

    if current_user.is_authenticated() and current_user == streamer:
        if request.method == 'POST':
            if info_form.submit_button.data:
                if info_form.validate_on_submit():
                    current_user.populate(info_form)
                    db.session.commit()
                    flash("Updated successfully", category='success')
                    return redirect(url_for('.streamer_page', streamer_name=streamer_name, page=page))
                else:
                    return render_template('streamer.html', streamer=streamer,
                                           streams=streams, info_form=info_form,
                                           title_form=title_form, edit_info=True,
                                           edit_title=False, wpc_stream=wpc_stream)

            elif title_form.submit_button.data:
                if title_form.validate_on_submit():
                    wpc_stream.title = title_form.title.data
                    db.session.commit()
                    return jsonify(newTitle=Markup.escape(title_form.title.data))

                else:
                    return render_template('streamer.html', streamer=streamer,
                                           streams=streams, info_form=info_form,
                                           title_form=title_form, edit_info=False,
                                           edit_title=True, wpc_stream=wpc_stream)
        else:
            info_form.youtube_channel.data = current_user.youtube_channel
            info_form.twitch_channel.data = current_user.twitch_channel
            info_form.info.data = current_user.info
            if wpc_stream:
                title_form.title.data = wpc_stream.title

    return render_template('streamer.html', streamer=streamer,
                           streams=streams, info_form=info_form,
                           title_form=title_form, edit_info=False,
                           edit_title=False, wpc_stream=wpc_stream)
コード例 #24
0
ファイル: utils.py プロジェクト: Starch/pelican
def slugify(value, substitutions=()):
    """
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.

    Took from Django sources.
    """
    # TODO Maybe steal again from current Django 1.5dev
    value = Markup(value).striptags()
    # value must be unicode per se
    import unicodedata
    from unidecode import unidecode
    # unidecode returns str in Py2 and 3, so in Py2 we have to make
    # it unicode again
    value = unidecode(value)
    if isinstance(value, six.binary_type):
        value = value.decode('ascii')
    # still unicode
    value = unicodedata.normalize('NFKD', value).lower()

    # backward compatible covert from 2-tuples to 3-tuples
    new_subs = []
    for tpl in substitutions:
        try:
            src, dst, skip = tpl
        except ValueError:
            src, dst = tpl
            skip = False
        new_subs.append((src, dst, skip))
    substitutions = tuple(new_subs)

    # by default will replace non-alphanum characters
    replace = True
    for src, dst, skip in substitutions:
        orig_value = value
        value = value.replace(src.lower(), dst.lower())
        # if replacement was made then skip non-alphanum
        # replacement if instructed to do so
        if value != orig_value:
            replace = replace and not skip

    if replace:
        value = re.sub(r'[^\w\s-]', '', value).strip()
        value = re.sub(r'[-\s]+', '-', value)
    else:
        value = value.strip()

    # we want only ASCII chars
    value = value.encode('ascii', 'ignore')
    # but Pelican should generally use only unicode
    return value.decode('ascii')
コード例 #25
0
ファイル: importer.py プロジェクト: emanuil-tolev/fundfind
    def share_fundopp(self, request, id_=None):
        '''Import information about a funding opportunity into the index.'''
        
        
        tmpl = util.clean_list(request.values.getlist('useful_links[]'))
        useful_links = []
        for link in tmpl:
            useful_links.append(util.prep_link(link))
        
        if not id_:
            id_ = util.slug_id(request.values["title"])

        record = {
            "funder": request.values.get("funder", ''),
            "title": request.values["title"],
            "residency": request.values.get("residency"),
            "gender": request.values.get("gender"),
            "id": id_,
            "url": util.prep_link(request.values.get("url",'')),
            "description": Markup.escape(request.values.get("more_info",'')),
            "issue_date": request.values.get('issue_date',None),
            "closing_date": request.values.get('closing_date',None),
            "funds": request.values.get('funds',''),
            "funds_exactly_or_upto": request.values.get('funds_exactly_or_upto',''),
            "useful_links": useful_links,
            "tags": util.clean_list(request.values.get("tags",'').split(",")), 
            "subjects": util.clean_list(request.values.get("subjects",'').split(",")),
            "created": datetime.now().isoformat(),
            "modified": datetime.now().isoformat(),
            "owner": self.owner.id,
            "license": CROWDSOURCE_CONTRIB_LICENSE,
            "origin": "Crowdsourced",
            "origin_method": "crowdsourced"
        }

        # cause ElasticSearch exceptions if null or empty string
        # so just remove them from the document
        if not record['issue_date']: del record['issue_date']
        if not record['closing_date']: del record['closing_date']
        
        fundfind.dao.FundingOpp.upsert(record)
        return id_
コード例 #26
0
ファイル: views.py プロジェクト: srault95/widukind-web
    def contact_form():
        is_modal = request.args.get('modal', default=0, type=int)
        
        if request.method == "GET":
            return render_template("contact.html", is_modal=is_modal)
        
        field_src = request.args
        if request.method == "POST":
            field_src = request.form

        msg = {"msg": "Your message has been registred.", "category": "success"}
        try:
            contact = dict(
                user_agent = str(request.user_agent),
                remote_addr = request.remote_addr,
                created = arrow.utcnow().datetime,
                fullName = field_src.get('fullName'),
                companyName = field_src.get('companyName'),
                subject = field_src.get('subject'),
                email = field_src.get('email'),
                message = Markup.escape(field_src.get('message'))
            )
            queries.col_contact().insert(contact)
            #flash("Your message has been registred.", "success")
            message = Message("Widukind - new contact from [%s]" % contact['email'],
                              sender=current_app.config.get('MAIL_DEFAULT_SENDER'),
                              recipients=[current_app.config.get('MAIL_ADMINS')])
            message.html = '<a href="%s">Admin contacts</a>' % url_for('admin.contacts', _external=True)
            try:
                mail.send(message)
            except Exception as err:
                current_app.logger.fatal(str(err))
            
        except Exception as err:
            #flash("Sorry, An unexpected error has occurred. Your message has not registred.", "error")
            msg = {"msg": "Sorry, An unexpected error has occurred. Your message has not registred.", "category": "error"}
            current_app.logger.fatal(str(err))
        
        return jsonify({"notify": msg, "redirect": url_for('home', _external=True)})
コード例 #27
0
ファイル: views.py プロジェクト: mrigor/blogly
def comment_reply(request, type, parent_id):
    parent_comment = Comment.objects.get(id=parent_id)
    response = {}
    if not parent_comment:
        response['error'] = 'Parent comment not found'
    if request.POST:
        form = CommentForm(request.POST)
        if form.is_valid():
            comment = CommentForm(request.POST).save(commit=False)
            comment.thread_id, comment.reverse_thread_id = \
                    get_thread_id(type, parent_comment.thing_id, parent_comment)
            comment.author = request.user
            comment.thing_id = parent_comment.thing_id
            comment.type = type
            comment.parent_id = parent_comment.id
            comment.save()
            response['content'] = Markup.unescape(
                Markup(
                    render_to_string(request, 'comments/comment.html', {'comment': comment})
                )
            )

    return render_to_remote_response(request, json_context=response)
コード例 #28
0
 def test_forceescape(self):
     tmpl = env.from_string('{{ x|forceescape }}')
     assert tmpl.render(x=Markup('<div />')) == u'&lt;div /&gt;'
コード例 #29
0
from datacube.index.fields import Field
from datacube.model import Dataset, DatasetType, Range

from . import _utils as utils

# How far to step the number when the user hits up/down.
NUMERIC_STEP_SIZE = {
    "numeric-range": 0.001,
    "double-range": 0.001,
    "integer-range": 1,
    "numeric": 0.001,
    "double": 0.001,
    "integer": 1,
}

CROSS_SYMBOL = Markup('<i class="fa fa-times" aria-label="x"></i>')

_LOG = logging.getLogger(__name__)
bp = Blueprint("filters", __name__)


@bp.app_template_filter("printable_time")
def _format_datetime(date):
    return date.strftime("%Y-%m-%d %H:%M:%S")


@bp.app_template_filter("printable_dataset")
def _dataset_label(dataset):
    label = utils.dataset_label(dataset)
    # If archived, strike out the label.
    if dataset.archived_time:
コード例 #30
0
ファイル: activity.py プロジェクト: gnott/h
    def search(self):
        result = self._check_access_permissions()
        if result is not None:
            return result

        check_slug(self.group, self.request)

        result = super(GroupSearchController, self).search()

        result['opts'] = {'search_groupname': self.group.name}

        if self.request.user not in self.group.members:
            return result

        def user_annotation_count(aggregation, userid):
            for user in aggregation:
                if user['user'] == userid:
                    return user['count']
            return 0

        q = query.extract(self.request)
        users_aggregation = result['search_results'].aggregations.get('users', [])
        members = [{'username': u.username,
                    'userid': u.userid,
                    'count': user_annotation_count(users_aggregation,
                                                   u.userid),
                    'faceted_by': _faceted_by_user(self.request,
                                                   u.username,
                                                   q)}
                   for u in self.group.members]
        members = sorted(members, key=lambda k: k['username'].lower())

        group_annotation_count = None
        if self.request.feature('total_shared_annotations'):
            group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid)

        result['stats'] = {
            'annotation_count': group_annotation_count,
        }

        result['group'] = {
            'created': self.group.created.strftime('%B, %Y'),
            'description': self.group.description,
            'name': self.group.name,
            'pubid': self.group.pubid,
            'url': self.request.route_url('group_read',
                                          pubid=self.group.pubid,
                                          slug=self.group.slug),
            'members': members,
        }

        if self.request.has_permission('admin', self.group):
            result['group_edit_url'] = self.request.route_url(
                'group_edit', pubid=self.group.pubid)

        result['more_info'] = 'more_info' in self.request.params

        if not result.get('q'):
            result['zero_message'] = Markup(_(
                'The group “{name}” has not made any annotations yet.').format(
                    name=Markup.escape(self.group.name)))

        return result
コード例 #31
0
def jsonify_2_script(data):
    return Markup(
        anyjson.serialize(data).replace('<script>', '<scri"+"pt>').replace(
            '</script>', '</scri"+"pt>'))
コード例 #32
0
def utcnow():
    return Markup(datetime.datetime.utcnow())
コード例 #33
0
def nl2br(eval_ctx, value):
    result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', '<br>\n') \
        for p in _paragraph_re.split(escape(value)))
    if eval_ctx.autoescape:
        result = Markup(result)
    return result
コード例 #34
0
 def s2md(text):
     return Markup(
         markdown(text, extras=['fenced-code-blocks', 'hilite', 'tables']))
コード例 #35
0
 def _render(self, csrf_token):
     from django.template.defaulttags import CsrfTokenNode
     return Markup(CsrfTokenNode().render({'csrf_token': csrf_token}))
コード例 #36
0
 def render_data(self):
     return Markup('<br>'.join(self.data or []))
コード例 #37
0
def nl2br(value):
    result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', Markup('<br>\n'))
                          for p in _paragraph_re.split(escape(value)))
    return result
コード例 #38
0
 def _summary_formatter(view, context, model, name):
     return Markup("%s" % (model.summary)) if model.summary else ""
コード例 #39
0
 def test_escaped(self):
     env = Environment(autoescape=True)
     tmpl = env.from_string('{{ x is escaped }}|{{ y is escaped }}')
     assert tmpl.render(x='foo', y=Markup('foo')) == 'False|True'
コード例 #40
0
def public_email(email):
    """Email address -> publicly displayable email."""
    return Markup('<span class="email">%s</span>' % unicode_to_html(email))
コード例 #41
0
 def include_jquery(version=None):
     if version is None:
         version = current_app.config.get('TOASTR_JQUERY_VERSION')
     js = ('<script src="//code.jquery.com/' +
           'jquery-{0}.min.js"></script>'.format(version))
     return Markup(js)
コード例 #42
0
 def _prerun_notes_formatter(view, context, model, name):
     return Markup("%s" %
                   (model.prerun_notes)) if model.prerun_notes else ""
コード例 #43
0
def index():
    c = bar_base()
    return Markup(c.render_embed())
コード例 #44
0
 def render(value):
     return Markup(self.render_markdown(value))
コード例 #45
0
def f_tex2utf(text: JinjaFilterInput, greek: bool = True) -> Markup:
    """Return output of tex2utf function as escaped Markup."""
    if isinstance(text, Markup):
        return escape(tex2utf(text.unescape(), greek=greek))
    else:
        return Markup(escape(tex2utf(text, greek=greek)))
コード例 #46
0
def embed_content(path: str) -> Markup:
    """Embed the content of a static file."""
    stat = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static')
    with open(os.path.join(stat, path)) as f:
        return Markup(f.read())
コード例 #47
0
ファイル: activity.py プロジェクト: chinmaygghag/h
    def search(self):
        result = self._check_access_permissions()
        if result is not None:
            return result

        check_slug(self.group, self.request)

        result = super(GroupSearchController, self).search()

        result['opts'] = {'search_groupname': self.group.name}

        # If the group has read access only for members  and the user is not in that list
        # return without extra info.
        if self.group.readable_by == ReadableBy.members and (self.request.user not in self.group.members):
            return result

        def user_annotation_count(aggregation, userid):
            for user in aggregation:
                if user['user'] == userid:
                    return user['count']
            return 0

        q = query.extract(self.request)
        members = []
        moderators = []
        users_aggregation = result['search_results'].aggregations.get('users', [])
        # If the group has members provide a list of member info,
        # otherwise provide a list of moderator info instead.
        if self.group.members:
            members = [{'username': u.username,
                        'userid': u.userid,
                        'count': user_annotation_count(users_aggregation,
                                                       u.userid),
                        'faceted_by': _faceted_by_user(self.request,
                                                       u.username,
                                                       q)}
                       for u in self.group.members]
            members = sorted(members, key=lambda k: k['username'].lower())
        else:
            moderators = []
            if self.group.creator:
                # Pass a list of moderators, anticipating that [self.group.creator]
                # will change to an actual list of moderators at some point.
                moderators = [{'username': u.username,
                               'userid': u.userid,
                               'count': user_annotation_count(users_aggregation,
                                                              u.userid),
                               'faceted_by': _faceted_by_user(self.request,
                                                              u.username,
                                                              q)}
                              for u in [self.group.creator]]
                moderators = sorted(moderators, key=lambda k: k['username'].lower())

        group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid)

        result['stats'] = {
            'annotation_count': group_annotation_count,
        }
        result['group'] = {
            'created': utc_us_style_date(self.group.created),
            'description': self.group.description,
            'name': self.group.name,
            'pubid': self.group.pubid,
            'url': self.request.route_url('group_read',
                                          pubid=self.group.pubid,
                                          slug=self.group.slug),
            'share_subtitle': _('Share group'),
            'share_msg': _('Sharing the link lets people view this group:'),
            'organization': {'name': self.group.organization.name,
                             'logo': self._organization_context.logo}
        }

        if self.group.type == 'private':
            result['group']['share_subtitle'] = _('Invite new members')
            result['group']['share_msg'] = _('Sharing the link lets people join this group:')

        result['group_users_args'] = [
            _('Members'),
            moderators if self.group.type == 'open' else members,
            self.group.creator.userid if self.group.creator else None,
        ]

        if self.request.has_permission('admin', self.group):
            result['group_edit_url'] = self.request.route_url(
                'group_edit', pubid=self.group.pubid)

        result['more_info'] = 'more_info' in self.request.params

        if not result.get('q'):
            result['zero_message'] = Markup(_(
                'The group “{name}” has not made any annotations yet.').format(
                    name=Markup.escape(self.group.name)))

        result['show_leave_button'] = self.request.user in self.group.members

        return result
コード例 #48
0
ファイル: activity.py プロジェクト: bibliotechie/h
    def search(self):  # pylint: disable=too-complex
        result = self._check_access_permissions()
        if result is not None:
            return result

        check_slug(self.group, self.request)

        result = super().search()

        result["opts"] = {"search_groupname": self.group.name}

        # If the group has read access only for members  and the user is not in that list
        # return without extra info.
        if self.group.readable_by == ReadableBy.members and (
                self.request.user not in self.group.members):
            return result

        def user_annotation_count(aggregation, userid):
            for user in aggregation:
                if user["user"] == userid:
                    return user["count"]
            return 0

        members = []
        moderators = []
        users_aggregation = result["search_results"].aggregations.get(
            "users", [])
        # If the group has members provide a list of member info,
        # otherwise provide a list of moderator info instead.
        if self.group.members:
            members = [{
                "username":
                u.username,
                "userid":
                u.userid,
                "count":
                user_annotation_count(users_aggregation, u.userid),
                "faceted_by":
                _faceted_by_user(self.request, u.username,
                                 self.parsed_query_params),
            } for u in self.group.members]
            members = sorted(members, key=lambda k: k["username"].lower())
        else:
            moderators = []
            if self.group.creator:
                # Pass a list of moderators, anticipating that [self.group.creator]
                # will change to an actual list of moderators at some point.
                moderators = [{
                    "username":
                    u.username,
                    "userid":
                    u.userid,
                    "count":
                    user_annotation_count(users_aggregation, u.userid),
                    "faceted_by":
                    _faceted_by_user(self.request, u.username,
                                     self.parsed_query_params),
                } for u in [self.group.creator]]
                moderators = sorted(moderators,
                                    key=lambda k: k["username"].lower())

        group_annotation_count = self._get_total_annotations_in_group(
            result, self.request)

        result["stats"] = {"annotation_count": group_annotation_count}
        result["group"] = {
            "created":
            utc_us_style_date(self.group.created),
            "description":
            self.group.description,
            "name":
            self.group.name,
            "pubid":
            self.group.pubid,
            "url":
            self.request.route_url("group_read",
                                   pubid=self.group.pubid,
                                   slug=self.group.slug),
            "share_subtitle":
            _("Share group"),
            "share_msg":
            _("Sharing the link lets people view this group:"),
        }
        if self.group.organization:
            result["group"]["organization"] = OrganizationJSONPresenter(
                self.group.organization, self.request).asdict(summary=True)
        else:
            result["group"]["organization"] = None

        if self.group.type == "private":
            result["group"]["share_subtitle"] = _("Invite new members")
            result["group"]["share_msg"] = _(
                "Sharing the link lets people join this group:")

        result["group_users_args"] = [
            _("Members"),
            moderators if self.group.type == "open" else members,
            self.group.creator.userid if self.group.creator else None,
        ]

        if self.request.has_permission("admin", self.group):
            result["group_edit_url"] = self.request.route_url(
                "group_edit", pubid=self.group.pubid)

        result["more_info"] = "more_info" in self.request.params

        if not result.get("q"):
            result["zero_message"] = Markup(
                _("The group “{name}” has not made any annotations yet.").
                format(name=Markup.escape(self.group.name)))

        result["show_leave_button"] = self.request.user in self.group.members

        return result
コード例 #49
0
 def description():
     return (icon("github") + Markup(" GitHub commits ") +
             icon("caret-right") + Markup(" builds.sr.ht jobs"))
コード例 #50
0
def _product_link(product_name):
    url = flask.url_for("overview_page", product_name=product_name)
    return Markup(f"<a href='{url}' class='product-name'>{product_name}</a>")
コード例 #51
0
ファイル: auth.py プロジェクト: sobolevV/market
from flask import Blueprint, url_for, redirect, request, render_template, abort

from flask_security.decorators import login_required, roles_required
from flask_security.utils import login_user, logout_user, hash_password
from flask_security.core import current_user
from flask_login import login_user, logout_user

from flask_mail import Message

from itsdangerous.url_safe import URLSafeTimedSerializer
from itsdangerous.exc import BadSignature, SignatureExpired
from jinja2 import Markup
from datetime import datetime

confirm_time = 3  # hours
invalid_token_markup = Markup(f"""<h3>Время для подтверждения истекло</h3><br>
                                  Проведите повторную регистрацию для подтверждения""")
signer = URLSafeTimedSerializer(secret_key=app.config.get("SECRET_KEY"))

bp_auth = Blueprint('auth', __name__, url_prefix='/auth', template_folder="templates")


# !!!! Переделать - убрать тут и добавить в html
def collect_warnings(form_errors) -> list:
    """Collect all warning in form and return
        :returns list of strings"""
    warnings = []
    for errors in form_errors.values():
        warnings += errors
    return warnings

コード例 #52
0
def _fast_tojson(obj):
    return Markup(rapidjson.dumps(obj))
コード例 #53
0
 def _description_formatter(view, context, model, name):
     return Markup("%s" % (model.description)) if model.description else ""
コード例 #54
0
 def render_data(self):
     return Markup('<a href="mailto:%s">%s</a>' % (self.data, self.data))
コード例 #55
0
 def _run_info_formatter(view, context, model, name):
     return Markup("%s" % (model.run_info)) if model.run_info else ""
コード例 #56
0
 def _dependencies_formatter(view, context, model, name):
     return Markup("%s" %
                   (model.dependencies)) if model.dependencies else ""
コード例 #57
0
 def _note_formatter(view, context, model, name):
     return Markup("%s" % (model.note)) if model.note else ""
コード例 #58
0
ファイル: json.py プロジェクト: zytx121/flask
def tojson_filter(obj, **kwargs):
    return Markup(htmlsafe_dumps(obj, **kwargs))
コード例 #59
0
ファイル: lebonsite.py プロジェクト: ClementNotin/lebonsite
def nl2br(eval_ctx, value):
    value = Markup.escape(value)
    result = re.sub(_paragraph_re, Markup("<br/>"), value)
    if eval_ctx.autoescape:
        result = Markup(result)
    return result
コード例 #60
0
 def _storage_formatter(view, context, model, name):
     return Markup("%s" % (model.storage)) if model.storage else ""