コード例 #1
0
ファイル: catmailer.py プロジェクト: NickCarneiro/catmailer
def unsubscribe(email_address):
    try:
        unsub_email = Email.query.filter_by(email_address=email_address).first()
        db.session.delete(unsub_email)
        db.session.commit()
        return 'Succesfully unsubscribed ' + strip_html(email_address)
    except Exception as e:
        app.logger.error(e)
        return 'Something went wrong trying to unsubscribe ' + strip_html(email_address) \
               + '. Try again later.'
コード例 #2
0
ファイル: models.py プロジェクト: luoxinliang/pyblog
def send_email(sender, instance, **kwargs):
    comment = instance
    
    if settings.ENABLE_EMAIL and comment.visible == True:
        t = loader.get_template("blog/coolblue/email.tpl")
        type = 0 if comment.content_type.model == 'article' else 1
        
        c = Context({
            'type': type,
            'comment': comment,
            'site': settings.SITE
        })
        
        html = t.render(c)
        plain_text = strip_html(html)
        
        subject = ''
        to_email = ''
        if not comment.reply_to_comment:
            to_email = [settings.ADMINS[0][1], ]
            if type == 0:
                subject = u'【残阳似血的博客】上的文章刚刚被%s评论了' % comment.username
            else:
                subject = u'【残阳似血的博客】刚刚收到%s的留言' % comment.username
        else:
            to_email = [comment.reply_to_comment.email_address, ]
            if type == 0:
                subject = u'您在【残阳似血的博客】上的评论刚刚被%s回复了' % comment.username
            else:
                subject = u'您在【残阳似血的博客】上的留言刚刚被%s回复了' % comment.username
        
        from_email = settings.EMAIL_HOST_USER
        send_mail(subject, plain_text, from_email, to_email, html=html)
コード例 #3
0
ファイル: models.py プロジェクト: luoxinliang/pyblog
def send_subscribers_email(sender, instance, **kwargs):
    article = instance
    
    if settings.ENABLE_EMAIL:
        subject = u'您订阅的【残阳似血的博客】上的文章有了更新'
        from_email = settings.EMAIL_HOST_USER
        t = loader.get_template("blog/coolblue/subscriberemail.tpl")
        
        for subscriber in Subscriber.enabled_objects.all():
            if ArticleSubscriber.objects.filter(article=article, subscriber=subscriber).count() == 0:
                article_subscriber = ArticleSubscriber(article=article, subscriber=subscriber)
                article_subscriber.save()
                
                to_email = [subscriber.email_address, ]
                
                c = Context({
                    'article': article,
                    'subscriber': subscriber,
                    'parameter': urllib.urlencode({
                                   'email': to_email[0],
                                   'hv': hashlib.md5("%s%s"%(to_email[0], str(subscriber.subscribe_time))).hexdigest()
                                   }),
                    'site': settings.SITE
                })
                html = t.render(c)
                plain_text = strip_html(html)
                send_mail(subject, plain_text, from_email, to_email, html=html)
コード例 #4
0
ファイル: social_sync.py プロジェクト: luoxinliang/pyblog
def get_sync_content(article, client, social_type):
    # Title
    title = article.title
    title_count = sina_client.count_words(title)
    
    # Short url
    url = '%s%s' % (settings.SITE, article.get_absolute_url())
    if hasattr(client, 'get_short_url'):
        short_url = client.get_short_url(url)
    else:
        short_url = url
    short_url_count = sina_client.count_words(short_url)
    
    # Base content
    base = u"发表了文章《》 - ... "
    base_count = sina_client.count_words(base)
    
    rest_count = MAX_WORDS - title_count - short_url_count - base_count
    
    rest_content = ''
    for word in iter(strip_html(article.content)):
        rest_count -= sina_client.count_words(word)
        threshold = 0 if not social_type==2 else 3
        if rest_count < threshold:
            break
        rest_content += word
        
    content = u"发表了文章《%s》 - %s... %s" % (title, rest_content, short_url)
    return content
コード例 #5
0
ファイル: __init__.py プロジェクト: edward01/Portal3_new
	def spiel(self, id, code=None):
		msg = self.spiels[id]
		if code != None and True: # make this configurable
			msg = '%s (%s)' % (msg, code)

		if not request.is_jquery:
			msg = utils.strip_html(msg)
		return msg.replace('#URL', 'https://%s' % (request.source['portal_ip']))
コード例 #6
0
  def post(self):
    method = self.request.get("_method")
    key = utils.url_to_entity_key(self.request.uri)
    if key:
      playlist = db.get(db.Key(key))
      if playlist:
        current_user = utils.get_current_user()
    
        #Get corresponding link
        library_item = playlist.library_item_for_user(current_user)
    
        if method == "PUT":
          need_version_control = False
          playlist_changed = False
      
          if(self.request.get('position')): #Rights: Can always update this
            current_user.re_sort_playlists(library_item, int(self.request.get('position')))        

          if (playlist.collaborative or library_item.is_owner): #Rights: Owner or collaborators can update this
            if playlist.smart:
              utils.parse_smart_filters(playlist, self.request)
              playlist_changed = True
            if self.request.get('tracks'):
              playlist.tracks = self.request.get('tracks')
              playlist_changed = True

            need_version_control = playlist.collaborative

          if library_item.is_owner: #Rights: Only owner can update this
            if(self.request.get('name') and len(self.request.get('name')) > 0):
              playlist.name = utils.strip_html(self.request.get('name'))
              playlist_changed = True
            if(self.request.get('collaborative')):
              playlist.collaborative = utils.convert_javascript_bool_to_python(self.request.get('collaborative'))
              playlist_changed = True
      
          if playlist_changed:
            if need_version_control: 
              if self.request.get('version') and not int(self.request.get('version')) < playlist.version:
                playlist.version += 1
                playlist.put()
                self.response.out.write(utils.status_code_json(200))
              else:
                self.response.out.write(library_item.serialize())
            else:
              playlist.put()
              self.response.out.write(utils.status_code_json(200))
          else:
            self.response.out.write(utils.status_code_json(200))
            
        elif method == "DELETE":
          library_item.delete()
          current_user.re_index_playlists()
          if not playlist.has_user():
            playlist.delete()
          self.response.out.write(utils.status_code_json(200))
コード例 #7
0
 def _update_ippsec(self):
   self.ipsc = {
     "url": "https://ippsec.rocks/dataset.json",
     "count": 0,
     "entries": {}
   }
   entries = utils.download_json(self.ipsc["url"])
   for entry in entries:
     if not entry.get("videoId", None):
       continue
     name = utils.strip_html(entry["machine"])
     video_url = "https://www.youtube.com/watch?v=%s&t=0" % (entry["videoId"])
     hours = int(entry["timestamp"]["minutes"] // 60); minutes = entry["timestamp"]["minutes"] - (hours*60)
     timestamp = "%02d:%02d:%02d" % (hours, minutes, entry["timestamp"]["seconds"])
     totalseconds = (entry["timestamp"]["minutes"]*60) + entry["timestamp"]["seconds"]
     tsurl = "https://www.youtube.com/watch?v=%s&t=%ds" % (entry["videoId"], totalseconds)
     desc = "%s - %s" % (timestamp, utils.strip_html(entry["line"]))
     if name not in self.ipsc["entries"]:
       self.ipsc["count"] += 1
       self.ipsc["entries"][name] = {
         "video_url": video_url,
         "description": {
           desc: tsurl
         }
       }
     else:
       self.ipsc["entries"][name]["description"][desc] = tsurl
   if len(self.ipsc["entries"]):
     for machine in self.stats["machines"]:
       if self.ipsc and self.ipsc.get("entries") and self.ipsc["entries"]:
         for entry in self.ipsc["entries"]:
           if machine["infrastructure"] in entry.lower().strip() and machine["name"].lower().strip() in entry.lower().strip():
             machine["writeups"] = {
               "ippsec": {
                 "name": entry,
                 "video_url": self.ipsc["entries"][entry]["video_url"],
                 "description": self.ipsc["entries"][entry]["description"],
               }
             }
     utils.info("[update.ippsec] added %d machine writeup descriptions from ippsec" % (self.ipsc["count"]))
コード例 #8
0
    def check_req(self, username):
        from main import API_BASE_URL
        # Connects to the API and checks if everything is good to go
        try:
            res = requests.get(API_BASE_URL + "check/",
                               params={"user": username})
        except ConnectionError as e:
            return False, f"Connection error: {e}", "Connection error."

        if res.status_code == 200:
            data = res.json()
            return data['linked'], "", ""

        content = strip_html(res.content.decode("utf-8"))
        return False, f"HTTP error {res.status_code} - {content}", "Connection error."
コード例 #9
0
    def start_req(self, link_code):
        from main import API_BASE_URL
        try:
            res = requests.get(API_BASE_URL + "start/",
                               params={"link_code": link_code})
        except ConnectionError as e:
            return False, f"Connection error: {e}", "Connection error."
        if res.status_code == 200:
            data = res.json()
            if data.get("error", False):
                return False, data['msg'], data['short_msg']
            else:
                return True, "", ""

        content = strip_html(res.content.decode("utf-8"))
        return False, f"HTTP error {res.status_code} - {content}", "Connection error."
コード例 #10
0
    def get(self):
        entries = query.get_fresh_entries(self.db, 3)
        new = self.get_arguments("new", None)
        for entry in entries:
            entry["summary"] = utils.strip_html(
                    markdown.markdown(entry["markdown"])
            )
            #show abstract only
            if len(entry["summary"]) > 300:
                entry["summary"] = entry["summary"][:300]
            entry["date"] = entry["published"]

        user = self.get_current_user()
        
        
        args = locals()
        args.pop('self')
        self.render("index.html", **args)
コード例 #11
0
ファイル: models.py プロジェクト: luoxinliang/pyblog
def renren_share(sender, instance, **kwargs):
    article = instance
    
    if settings.ENABLE_RENREN_ACCOUNT \
        and article.status == 2 \
        and article.share \
        and article.shares.filter(type=3).count() == 0:
        
        content = u'残阳似血的博客发表了文章《%s》 - %s' % (article.title,
                                              strip_html(article.content[:100]+"..."))
        content = content.encode('utf-8')

        renren_share = renren_client('share.share',
                            url='%s%s' % (settings.SITE, article.get_absolute_url()),
                            comment=content,
                            type=6)
        
        if 'error_code' in renren_share and renren_share['error_code'] != 0:
            return
        
        share_id = renren_share['id'] # 6 in renren api means this is a url
        content_type = ContentType.objects.get(model='article')
        share = SocialItem(share_id=share_id, content_type=content_type, type=3, object_id=article.id)
        share.save()
コード例 #12
0
    def _parse_machine_page(self, url):
        if not url:
            return
        match = re.search(r'/entry/(.+),(\d+)/', url)
        if not match:
            return
        shortname, mid, url = match.groups()[0], int(
            match.groups()[1]), "https://www.vulnhub.com/entry/%s,%s/" % (
                match.groups()[0], match.groups()[1])
        machinestats = {
            "avatar_thumb": None,
            "id": mid,
            "maker": {
                "id": None,
                "name": None,
                "url": None,
            },
            "series": {
                "id": None,
                "name": None,
                "url": None,
            },
            "name": None,
            "shortname": shortname,
            "os": None,
            "points": None,
            "difficulty": None,
            "description": None,
            "release": None,
            "url": url,
        }
        res = utils.get_http_res(url)
        page = res.text

        soup = BeautifulSoup(page, 'lxml')
        container = soup.find('div', id="description", class_="panel")
        if not container:
            return machinestats

        machinestats["description"] = "\n".join([
            para.text for para in container.find_all('p', recursive=True)
        ]).strip()

        # <li><b>Name</b>: Seppuku: 1</li>
        match = re.search(r'<li><b>Name</b>:\s*(.+)</li>', page, re.I)
        machinestats["name"] = utils.strip_html(
            match.groups()[0]) if match else None

        # <a href="/media/img/entry/
        match = re.search(r'<a href="/media/img/entry/([^"]+)', page, re.I)
        machinestats[
            "avatar_thumb"] = "https://www.vulnhub.com/media/img/entry/%s" % (
                utils.strip_html(match.groups()[0])) if match else None

        # <li><b>Date release</b>: 13 May 2020</li>
        match = re.search(r'<li><b>Date release</b>:\s*(.+)</li>', page, re.I)
        machinestats["release"] = utils.strip_html(
            match.groups()[0]) if match else None

        # <li><b>Author</b>: <a href="/author/suncsr-team,696/">SunCSR Team</a></li>
        match = re.search(
            r'<li><b>Author</b>:\s*<a href="/author/(.+),(\d+)/">(.+)</a></li>',
            page, re.I)
        if match:
            machinestats["maker"]["name"] = utils.strip_html(match.groups()[2])
            machinestats["maker"]["id"] = int(
                utils.strip_html(match.groups()[1]))
            machinestats["maker"][
                "url"] = "https://www.vulnhub.com/author/%s,%s/" % (
                    utils.strip_html(match.groups()[0]),
                    utils.strip_html(match.groups()[1]))

        # <li><b>Series</b>: <a href="/series/seppuku,318/">Seppuku</a></li>
        match = re.search(
            r'<li><b>Series</b>:\s*<a href="/series/(.+),(\d+)/">(.+)</a></li>',
            page, re.I)
        if match:
            machinestats["series"]["name"] = utils.strip_html(
                match.groups()[2])
            machinestats["series"]["id"] = int(
                utils.strip_html(match.groups()[1]))
            machinestats["series"][
                "url"] = "https://www.vulnhub.com/series/%s,%s/" % (
                    utils.strip_html(match.groups()[0]),
                    utils.strip_html(match.groups()[1]))

        # <li><b>Operating System</b>: Linux</li>
        match = re.search(r'<li><b>Operating System</b>:\s*(.+)</li>', page,
                          re.I)
        machinestats["os"] = utils.strip_html(
            match.groups()[0]) if match else None

        if machinestats["url"] in self.difficulty["easy"]:
            machinestats["difficulty"] = "easy"
        elif machinestats["url"] in self.difficulty["medium"]:
            machinestats["difficulty"] = "medium"
        elif machinestats["url"] in self.difficulty["hard"]:
            machinestats["difficulty"] = "hard"
        elif machinestats["url"] in self.difficulty["insane"]:
            machinestats["difficulty"] = "insane"

        if not machinestats["difficulty"]:
            # <li>Difficulty: Intermediate to Hard</li>
            # <li>Difficulty: <strong>Beginner to Intermediate</strong></li>
            match = re.search(
                r'<li>Difficulty\s*:\s*(<strong>)?(.+)(</strong>)?</li>', page,
                re.I)
            machinestats["difficulty"] = utils.strip_html(
                match.groups()[1]) if match else None

        if not machinestats["difficulty"]:
            # <p>Difficulty is Medium</p>
            # <p>Difficulty: Intermediate
            # <p>Difficulty : beginner/intermediate</p>
            # <p>Level : beginner for user flag and intermediate for root flag.</p>
            match = re.search(r'<p>(Difficulty|Level)\s*(is|:)\s*(.+)</p>',
                              page, re.I)
            machinestats["difficulty"] = utils.strip_html(
                match.groups()[2]) if match else None

        if not machinestats["difficulty"]:
            # An easy to intermediate boot2root
            match = re.search(r'easy\s+(to|/)\s+intermediate', page, re.I)
            machinestats["difficulty"] = "Easy/Intermediate" if match else None

        if not machinestats["difficulty"]:
            # beginner boot2root
            match = re.search(
                r'(beginner\s+boot2root|A piece of cake machine)', page, re.I)
            machinestats["difficulty"] = "Easy" if match else None

        if not machinestats["difficulty"]:
            # medium level difficulty
            match = re.search(r'(medium\s+level\s+difficulty)', page, re.I)
            machinestats["difficulty"] = "Medium" if match else None

        if not machinestats["difficulty"]:
            # <p>[BEGINNER - INTERMEDIATE]</p>
            # beginner to intermediate boot2root
            match = re.search(r'BEGINNER\s*(-|to)?\s*INTERMEDIATE', page, re.I)
            machinestats[
                "difficulty"] = "Beginner/Intermediate" if match else None

        if machinestats["difficulty"]:
            mapping = {
                "insane": ["insane"],
                "hard": ["hard", "difficult", "challenging", "intermediate++"],
                "medium": ["medium", "intermediate", "moderate", "beginner++"],
                "easy": ["easy", "beginner", "low"],
            }

            newdiff = None
            for normdiff in mapping["insane"]:
                if normdiff in machinestats["difficulty"].lower().strip():
                    newdiff = "insane"
                    break
            if not newdiff:
                for normdiff in mapping["hard"]:
                    if normdiff in machinestats["difficulty"].lower().strip():
                        newdiff = "hard"
                        break
            if not newdiff:
                for normdiff in mapping["medium"]:
                    if normdiff in machinestats["difficulty"].lower().strip():
                        newdiff = "medium"
                        break
            if not newdiff:
                for normdiff in mapping["easy"]:
                    if normdiff in machinestats["difficulty"].lower().strip():
                        newdiff = "easy"
                        break

            machinestats["difficulty"] = newdiff if newdiff else None
            machinestats["points"] = None

        return machinestats
コード例 #13
0
 def load(self, id, ext_kw = True):
     article = self.storage.load(id)
     if not article: return None
     if ext_kw: self._extend_keywords(article)
     article.text_content = utils.strip_html(article.content) if article.content else ''
     return article
コード例 #14
0
ファイル: handlers.py プロジェクト: asmedrano/sandy-mapper
    def get(self):
        """
        /api/ -- all items all data
        ?st= -- State Name
        ?city= -- city
        """
        results = []
        state = self.request.get('st', default_value=None)
        city = self.request.get('city', default_value=None)

        if state is not None or city is not None:
            # lets look up addresses first then grab relevant entries
            query = Address.all(keys_only=True)
            if state is not None:
                query.filter('state =', cgi.escape(state))
            if city is not None:
                query.filter('city =', cgi.escape(city))

            # at this point we have our addresses
            for addrs in query:
                e_query = Entry.all().filter('address =', addrs)
                for result in e_query:
                    entry = {}
                    entry['address'] = cgi.escape(strip_html(get_as_str(result.address))) if result.address else None
                    entry['time'] = cgi.escape(strip_html(str(result.time))) if result.time else None
                    entry['lat'] = result.address.geo_pt.lat
                    entry['lng'] = result.address.geo_pt.lon
                    entry['power_status'] =  cgi.escape(strip_html(result.power_status)) if result.power_status else None
                    entry['landline_status'] = cgi.escape(strip_html(result.landline_status)) if result.landline_status else None
                    entry['water_status'] = cgi.escape(strip_html(result.water_status)) if result.water_status else None
                    entry['road_status'] = cgi.escape(strip_html(result.road_status)) if result.road_status else None
                    entry['rain_fall'] = cgi.escape(strip_html(result.rain_fall)) if result.rain_fall else None
                    entry['visual_report'] = cgi.escape(strip_html(result.visual_report)) if result.visual_report else None
                    results.append(entry)
        else:
            query = Entry.all()
            for result in query:
                entry = {}
                entry['address'] = cgi.escape(strip_html(get_as_str(result.address))) if result.address else None
                entry['time'] = cgi.escape(strip_html(str(result.time))) if result.time else None
                entry['lat'] = result.address.geo_pt.lat
                entry['lng'] = result.address.geo_pt.lon
                entry['power_status'] =  cgi.escape(strip_html(result.power_status)) if result.power_status else None
                entry['landline_status'] = cgi.escape(strip_html(result.landline_status)) if result.landline_status else None
                entry['water_status'] = cgi.escape(strip_html(result.water_status)) if result.water_status else None
                entry['road_status'] = cgi.escape(strip_html(result.road_status)) if result.road_status else None
                entry['rain_fall'] = cgi.escape(strip_html(result.rain_fall)) if result.rain_fall else None
                entry['visual_report'] = cgi.escape(strip_html(result.visual_report)) if result.visual_report else None
                results.append(entry)

        self.response.headers['content-type'] = 'application/json'
        self.response.write(simplejson.dumps(results))
コード例 #15
0
    def post(self):
        method = self.request.get("_method")
        key = utils.url_to_entity_key(self.request.uri)
        if key:
            playlist = db.get(db.Key(key))
            if playlist:
                current_user = utils.get_current_user()

                #Get corresponding link
                library_item = playlist.library_item_for_user(current_user)

                if method == "PUT":
                    need_version_control = False
                    playlist_changed = False

                    if (self.request.get('position')
                        ):  #Rights: Can always update this
                        current_user.re_sort_playlists(
                            library_item, int(self.request.get('position')))

                    if (playlist.collaborative or library_item.is_owner
                        ):  #Rights: Owner or collaborators can update this
                        if playlist.smart:
                            utils.parse_smart_filters(playlist, self.request)
                            playlist_changed = True
                        if self.request.get('tracks'):
                            playlist.tracks = self.request.get('tracks')
                            playlist_changed = True

                        need_version_control = playlist.collaborative

                    if library_item.is_owner:  #Rights: Only owner can update this
                        if (self.request.get('name')
                                and len(self.request.get('name')) > 0):
                            playlist.name = utils.strip_html(
                                self.request.get('name'))
                            playlist_changed = True
                        if (self.request.get('collaborative')):
                            playlist.collaborative = utils.convert_javascript_bool_to_python(
                                self.request.get('collaborative'))
                            playlist_changed = True

                    if playlist_changed:
                        if need_version_control:
                            if self.request.get('version') and not int(
                                    self.request.get(
                                        'version')) < playlist.version:
                                playlist.version += 1
                                playlist.put()
                                self.response.out.write(
                                    utils.status_code_json(200))
                            else:
                                self.response.out.write(
                                    library_item.serialize())
                        else:
                            playlist.put()
                            self.response.out.write(
                                utils.status_code_json(200))
                    else:
                        self.response.out.write(utils.status_code_json(200))

                elif method == "DELETE":
                    library_item.delete()
                    current_user.re_index_playlists()
                    if not playlist.has_user():
                        playlist.delete()
                    self.response.out.write(utils.status_code_json(200))
コード例 #16
0
def test_strip_html():
    """
    test suppression des balises HTML
    """
    assert utils.strip_html("<div><br>Hello</div>") == "Hello"
コード例 #17
0
ファイル: __init__.py プロジェクト: edward01/Portal3_new
	def spiel(self, id):
		msg = self.spiels[id]
		if not request.is_jquery:
			msg = utils.strip_html(msg)
		return msg.replace('#URL', 'https://%s' % (request.source['portal_ip']))