Golang sanitize.HTML函数代码示例

// ReviewedProduct returns the string of the reviewed thing in a best-effort way.
func (article *Article) ReviewedProduct() string {
	if len(article.Front.Article.Products) == 0 {
		return ""
	}
	if article.Front.Article.Products[0].Source.Value != "" {
		return strings.TrimSpace(sanitize.HTML(article.Front.Article.Products[0].Source.Value))
	}
	// refs. #7111
	if article.Front.Article.Products[0].StringName.Value != "" {
		return strings.TrimSpace(sanitize.HTML(article.Front.Article.Products[0].StringName.Value))
	}
	return ""
}

func listenDeploys(lastMarker string, commandMsgs chan<- models.Message, connector models.Connector) (nextMarker string) {
	now := time.Now()
	nextMarker = strconv.FormatInt(now.Unix(), 10) + "000"
	if connector.Debug {
		log.Print("Calling deploy results with last marker: " + lastMarker)
	}
	d := bambooapi.DeployResults(connector.Server, connector.Login, connector.Pass)
	for _, de := range d {
		for _, e := range de.Environmentstatuses {
			buildTime := strconv.FormatInt(e.Deploymentresult.Finisheddate, 10)
			if e.Deploymentresult.ID > 0 && buildTime > lastMarker {
				var m models.Message
				m.In.ConnectorType = connector.Type
				m.In.ConnectorID = connector.ID
				m.In.Tags = connector.Tags
				m.In.Process = false
				m.Out.Text = "Bamboo Deploy " + e.Deploymentresult.Deploymentversion.Planbranchname + " " + e.Deploymentresult.Deploymentversion.Name + " to " + e.Environment.Name + " " + e.Deploymentresult.Deploymentstate
				m.Out.Detail = html.UnescapeString(sanitize.HTML(e.Deploymentresult.Reasonsummary))
				m.Out.Link = "https://" + connector.Server + "/builds/deploy/viewDeploymentResult.action?deploymentResultId=" + strconv.Itoa(e.Deploymentresult.ID)
				if e.Deploymentresult.Deploymentstate == "SUCCESS" {
					m.Out.Status = "SUCCESS"
				} else {
					m.Out.Status = "FAIL"
				}
				commandMsgs <- m
			}
		}
	}
	return nextMarker
}

// Public function
// permet d'ajouter un commenaire sur la page tutoriel
func TutorialNouvCommHandler(w http.ResponseWriter, r *http.Request) {
	// Validation des données
	// Si une des variables est vide, la func retourne un "error"
	// ce qui fait afficher un message d'erreur
	if r.PostFormValue("val_commentaire") == "" ||
		r.PostFormValue("val_post_id") == "" ||
		r.PostFormValue("val_auteur_id") == "" ||
		r.PostFormValue("val_auteur_id") == "0" {
		// envoie un message d'erreur
		renderString(w, "error")
	} else {
		// initialise l'objet ForumPost et récupère les données du formulaire
		var tp TutorialPost
		tp.TutorialId, _ = ParseInt(r.PostFormValue("val_post_id"), 0, 64)
		tp.UserId, _ = ParseInt(r.PostFormValue("val_auteur_id"), 0, 64)
		tp.Text = sanitize.HTML(r.PostFormValue("val_commentaire"))
		tp.IsOnline = 1
		tp.Id = tp.Save()
		// permet de récuprérer le nom de l'utilisateur
		var u User
		u.Id = tp.UserId
		u = u.GetById()
		// permet de convertir la date de la personne qui a posté la réponse
		t := time.Now()
		date := t.Format(dateLayout)
		// String qui contient d'abord l'auteur du commentaire
		// puis son commentaire complet, séparés par ":::"
		commData := u.FirstName + " " + u.LastName + ":::" + date + ":::" + tp.Text + ":::" + Itoa(int(tp.Id))
		renderString(w, commData)
	}
}

func main() {
	flag.Usage = usage
	flag.Parse()
	args := flag.Args()
	if len(args) != 1 {
		usage()
	}
	url := args[0]
	key := os.Getenv("READABILITY_PARSER_API_KEY")
	if key == "" {
		printMissingKeyMessage()
	}
	parser := readability.NewParserClient(key)
	article, resp, err := parser.Parse(url)
	if resp != nil && resp.StatusCode == 400 {
		usage()
	}
	if err != nil {
		printError(err)
	}
	content := sanitize.HTML(article.Content)
	// remove vertical whitespace
	r := regexp.MustCompile("[\n]{2,}")
	content = r.ReplaceAllString(content, "")
	// remove horizontal whitespace
	content = strings.Replace(content, "  ", "", -1)
	fmt.Println(article.Title + "\n")
	fmt.Println(strings.Replace(strings.TrimSpace(content), "\n", "\n\n", -1))
}

func (s *Service) Check(id string) (status string, err error) {
	body, err := s.Downloader(s.URL, id)
	if err != nil {
		return
	}

	if s.Extractor != nil {
		parts := s.Extractor.FindSubmatch(body)
		if parts == nil {
			return "", nil
		}

		status = string(parts[1])
	} else {
		doc, err := gokogiri.ParseHtml(body)
		if err != nil {
			return "", err
		}
		defer doc.Free()

		res, err := doc.Search(s.XPath)
		if err != nil {
			return "", err
		}
		if len(res) < 1 {
			return "", nil
		}

		status = sanitize.HTML(res[0].String())
		status = replacer.ReplaceAllString(status, " ")
		status = strings.TrimSpace(status)
	}

	return
}

func (bot *Bot) Google(query, channel string) {
	r, err := http.Get("http://ajax.googleapis.com/ajax/services/search/web?v=1.0&rsz=1&q=" + query)
	defer r.Body.Close()

	if err != nil {
		log.Println(err)
	}
	if r.StatusCode != http.StatusOK {
		log.Println(r.Status)
	}

	//create a custom struct for the json response
	//somehow Go magically transplants the response data into this
	var google struct {
		ResponseData struct {
			Results []struct {
				TitleNoFormatting string
				Content           string
				URL               string
			}
		}
	}

	//parse response body json to Go
	dec := json.NewDecoder(r.Body)
	dec.Decode(&google)

	//output results to channel
	for _, item := range google.ResponseData.Results {
		//fixme: sending commands
		content := sanitize.Accents(sanitize.HTML(item.Content))
		bot.SendMessage(item.TitleNoFormatting+" "+item.URL+" "+content, channel)
	}
}

func listenBuilds(lastMarker string, commandMsgs chan<- models.Message, connector models.Connector) (nextMarker string) {
	var displayOnStart = 0
	url := "https://" + connector.Login + ":" + connector.Pass + "@"
	url += connector.Server + "/builds/plugins/servlet/streams?local=true"
	feed, err := rss.Fetch(url)
	if err != nil {
		log.Print(err)
		return
	}
	for i := len(feed.Items) - 1; i >= 0; i-- {
		if connector.Debug {
			log.Print("Bamboo " + connector.ID + " item #" + strconv.Itoa(i) + " marker " + feed.Items[i].Date.String())
		}
		if lastMarker == "" {
			lastMarker = feed.Items[displayOnStart].Date.String()
		}
		item := feed.Items[i]
		if item.Date.String() > lastMarker {
			status := "NONE"
			if strings.Contains(item.Title, "successful") {
				status = "SUCCESS"
			}
			if strings.Contains(item.Title, "fail") {
				status = "FAIL"
			}
			var m models.Message
			m.In.ConnectorType = connector.Type
			m.In.ConnectorID = connector.ID
			m.In.Tags = connector.Tags
			m.In.Process = false
			m.Out.Text = "Bamboo Build " + html.UnescapeString(sanitize.HTML(item.Title))
			m.Out.Detail = html.UnescapeString(sanitize.HTML(item.Content))
			m.Out.Link = item.Link
			m.Out.Status = status
			commandMsgs <- m
			if i == 0 {
				lastMarker = item.Date.String()
			}
		}
	}
	nextMarker = lastMarker
	return nextMarker
}

func callRss(lastMarker string, commandMsgs chan<- models.Message, connector models.Connector) (nextMarker string) {
	var displayOnStart = 0
	if connector.Debug {
		log.Print("Starting rss feed fetch for " + connector.ID)
	}
	feed, err := rss.Fetch(connector.Server)
	if err != nil {
		log.Print(err)
		return
	}
	if connector.Debug {
		log.Print("Feed count for " + connector.ID + ": " + strconv.Itoa(len(feed.Items)))
	}
	for i := len(feed.Items) - 1; i >= 0; i-- {
		if connector.Debug {
			log.Print("Feed " + connector.ID + " item #" + strconv.Itoa(i) + " marker " + feed.Items[i].Date.String())
		}
		if lastMarker == "" {
			lastMarker = feed.Items[displayOnStart].Date.String()
		}
		item := feed.Items[i]
		if item.Date.String() > lastMarker {
			var m models.Message
			m.In.ConnectorType = connector.Type
			m.In.ConnectorID = connector.ID
			m.In.Tags = connector.Tags
			m.In.Process = false
			m.Out.Text = connector.ID + " " + html.UnescapeString(sanitize.HTML(item.Title))
			m.Out.Detail = html.UnescapeString(sanitize.HTML(item.Content))
			m.Out.Link = item.Link
			commandMsgs <- m
			if i == 0 {
				lastMarker = item.Date.String()
			}
		}
	}
	nextMarker = lastMarker
	if connector.Debug {
		log.Print("Next marker for " + connector.ID + ": " + nextMarker)
	}
	return nextMarker
}

func (c *connection) reader() {
	for {
		_, message, err := c.ws.ReadMessage()
		if err != nil {
			break
		}
		hello := strings.Split(sanitize.HTML(string(message)), "|")
		ck.Put(hello[0], hello[1])
	}
	c.ws.Close()
}

// permet de créer un userProject à partir d'un formulaire HTML
// et permet d'uploader une image associée
// et permet de croper l'image en fonction de sa vignette
func UPCreateAjaxHandler(w http.ResponseWriter, r *http.Request) {

	// création d'un user project
	var up UserProject
	// récupère l'id du user
	UserId, err := ParseInt(r.PostFormValue("id_user"), 0, 64)
	if err != nil {
		// envoie un message d'erreur
		renderString(w, "error")
	}
	up.UserId = UserId
	// crécuprère l'id de la cat
	up.UserProjectCategoryId, err = ParseInt(r.PostFormValue("id_cat"), 0, 64)
	if err != nil {
		// envoie un message d'erreur
		renderString(w, "error")
	}
	// récupère le titre
	up.Title = sanitize.HTML(r.PostFormValue("title"))
	// récupère la description
	up.Description = sanitize.HTML(r.PostFormValue("Description"))
	// permet d'uploader l'image
	up.Url, err = UploadImage(URL_PROJECT_IMAGES, r)
	if err != nil {
		// envoie un message d'erreur
		renderString(w, "error")
	}
	// permet de cropper l'image qui viens d'être uploadée
	err = CropImage(up.Url, 300, 300)
	if err != nil {
		// envoie un message d'erreur
		renderString(w, "error")
	}
	// finit de créer l'objet
	// définit le projet non visible
	up.IsOnline = 0
	// sauvegarde dans la base de donnée
	up.Id = up.Save()
	// retourne l'objet en JSON
	renderJson(w, up)
}

// loadTemplate load template from tpls/%s.tpl
func loadTemplate(Name string) *html.Template {
	funcMap := html.FuncMap{
		"html": func(val interface{}) html.HTML {
			switch value := val.(type) {
			case string:
				{
					return html.HTML(value)
				}
			case html.HTML:
				{
					return value
				}

			default:
				return html.HTML("Unsupported type for HTML pipeline")
			}
		},
		"typo": func(val string) string {
			return typo.Typo(val)
		},
		"striptags": func(val string) string {
			return sanitize.HTML(val)
		},
		// TODO: в разработке
		/*"mod": func(args ...interface{}) interface{} {
		    if len(args) == 0 {
		        return ""
		    }

		    name := args[0].(string)
		    ctx := new(context.Context)

		    if len(args) > 1 {
		        ctx = args[1].(*context.Context)
		    }

		    modules := reflect.ValueOf(modules.Get())
		    mod := modules.MethodByName(name)

		    if (mod == reflect.Value{}) {
		        return ""
		    }

		    inputs := make([]reflect.Value, 0)
		    inputs = append(inputs, reflect.ValueOf(ctx))

		    ret := mod.Call(inputs)
		    return ret[0].Interface()
		},*/
	}

	return html.Must(html.New("*").Funcs(funcMap).Delims("{{%", "%}}").ParseFiles("tpls/" + Name + ".tpl"))
}

func getWords(s string) []string {
	// Remove all html tags and such
	plainText := sanitize.HTML(s)

	// Remove all weird characters such as `"^ and so on that are not alphanumeric or spaces
	plainText = nonLetters.ReplaceAllString(plainText, "")

	// Replace all whitespace with 1 regular space
	plainText = whitespace.ReplaceAllString(plainText, " ")

	// Split the plaintext via the single space
	return strings.Split(plainText, " ")
}

//MinimalStandard returns a cleaned up standard
func (item XMLLearningStandardItem) MinimalStandard() MinimalStandard {
	standard := MinimalStandard{}

	if len(item.StatementCodes) > 0 {
		standard.Code = item.StatementCodes[0]
	}
	standard.Grades = item.GradeLevels
	if len(item.Statements) > 0 {
		standard.Text = sanitize.HTML(item.Statements[0])
	}

	return standard
}

func getCorrection(engine string, queryString string, c chan correctionResult) {
	resp, _ := http.Get(buildUrl(engine, queryString))
	page, _ := ioutil.ReadAll(resp.Body)
	doc, _ := gokogiri.ParseHtml(page)

	suggestedTermResult, err := doc.Root().Search(searchEngines[engine].suggestedTermQuery)
	suggestedTerm := "NULL"
	if err == nil && len(suggestedTermResult) > 0 {
		suggestedTerm = fmt.Sprintf("%v", suggestedTermResult[0])
	} else if err != nil {
		fmt.Println(err)
	}

	topLinkResult, err := doc.Root().Search(searchEngines[engine].topLinkQuery)
	topLink := "NULL"
	if err == nil && len(topLinkResult) > 0 {
		topLink = fmt.Sprintf("%v", topLinkResult[0])
	} else if err != nil {
		fmt.Println(err)
	}

	topTitleResult, err := doc.Root().Search(searchEngines[engine].topTitleQuery)
	topTitle := "NULL"
	if err == nil && len(topTitleResult) > 0 {
		topTitle = fmt.Sprintf("%v", topTitleResult[0])
	} else if err != nil {
		fmt.Println(err)
	}

	doc.Free()
	c <- correctionResult{
		engine:        engine,
		SuggestedTerm: sanitize.HTML(suggestedTerm),
		TopLink:       strings.TrimSpace(sanitize.HTML(topLink)),
		TopTitle:      strings.TrimSpace(sanitize.HTML(topTitle)),
		StatusCode:    resp.StatusCode,
	}
}

func GetIdeas() []map[string]interface{} {
	var (
		id        int
		name      string
		email     string
		link      string
		content   string
		timestamp int
	)

	ideas := make([]map[string]interface{}, 0)

	rows, _ := db.Query(`select id, name, email, link, content, strftime("%s", create_time) from idea order by id desc`)
	defer rows.Close()
	for rows.Next() {
		err := rows.Scan(&id, &name, &email, &link, &content, &timestamp)
		if err != nil {
			log.Fatal(err)
		}
		name = sanitize.HTML(name)
		email = sanitize.HTML(email)
		link = sanitize.HTML(link)
		content = sanitize.HTML(content)
		log.Println("Original content: " + content)
		html := string(blackfriday.MarkdownCommon([]byte(content)))
		log.Println("Converted: " + html)
		ideas = append(ideas, map[string]interface{}{
			"id":        id,
			"name":      name,
			"email":     email,
			"link":      link,
			"content":   content,
			"html":      html,
			"timestamp": timestamp,
		})
	}
	return ideas
}