Golang Render.Data方法代碼示例

func Answer(req *http.Request, r render.Render) {
	returnData := make(map[string]interface{})
	if req.Method == "GET" {
		blankList, choiceList, judgeList := appService.GetTitleId(1, 1, 1)
		returnData["blankList"] = blankList
		returnData["choiceList"] = choiceList
		returnData["judgeList"] = judgeList
		r.HTML(200, "answer", returnData)
		return
	}
	req.ParseForm()
	values := req.Form
	records := values.Get("records")
	if records == "" {
		r.Data(500, []byte("error"))
	}
	name, recordsList, err := appService.CheckRecords(records)
	if err != nil {
		r.Data(500, []byte("appService.CheckRecords error"))
	}
	returnData["name"] = name
	returnData["list"] = recordsList
	r.HTML(200, "record", returnData)
	return
}

func Index(session sessions.Session, r render.Render) {
	id, ok := session.Get("user_id").(int64)
	if !ok {
		r.Data(200, []byte("error"))
		return
	}

	list, err := ga.GetPermissionByUserId(id)
	if err != nil {
		r.Data(200, []byte("get error"))
		return
	}

	r.HTML(200, "list", map[string]interface{}{"list": list})
	return
}

// Markdown renders a POST request into HTML.
func (ap ApiRender) Markdown(r render.Render, req *http.Request) {
	if err := req.ParseForm(); err != nil {
		r.Data(500, []byte(err.Error()))
		return
	}

	if _, ok := req.Form["raw"]; !ok {
		r.Data(500, []byte("No Data"))
		return
	}

	raw := req.Form["raw"][0]
	data := util.Markdown([]byte(raw))

	r.JSON(200, apiRenderResponse{Data: string(data)})
}

func getCertificates(req *http.Request, params martini.Params, r render.Render) {

	format := req.URL.Query().Get("format")

	newCA, err := ca.NewCA(config["root-dir"])
	if err != nil {
		panic(err)
	}

	id := params["id"]
	idInt, err := strconv.Atoi(id)
	if err != nil {
		r.JSON(401, map[string]interface{}{
			"result": "wrong id",
		})
		return
	}
	cert, err := newCA.GetCertificate(int64(idInt))
	if err != nil {
		r.JSON(401, map[string]interface{}{
			"result": "cannot get cert",
		})
		return
	}

	pem, err := cert.ToPEM()
	if err != nil {
		r.JSON(401, map[string]interface{}{
			"result": "cannot get cert",
		})
		return
	}

	if format == "file" {
		r.Data(200, pem)
	} else {
		r.JSON(200, map[string]interface{}{
			"certificate": map[string]interface{}{
				"id":  cert.GetSerialNumber().Int64(),
				"crt": string(pem),
				//"csr": csr,
			},
		})
	}

}

// Create allows for the creation of new posts. It returns a 204
// response on creation or a 500 response on error.
func (ap ApiPosts) Create(r render.Render, req *http.Request) {
	var (
		post models.Post
		err  error
		t    = "urlencoded"
		p    interface{}
	)
	root := util.Config().App.PostsDir
	contentType := req.Header.Get("content-type")

	if strings.Contains(contentType, "application/json") {
		t = "json"
	}

	switch t {
	case "json":
		dec := json.NewDecoder(req.Body)
		err = dec.Decode(&post)
		p = post
	default:
		err = req.ParseForm()
		p = req.Form
	}

	if err != nil {
		r.Data(500, []byte(err.Error()))
		return
	}

	if err = models.SavePost(root, p); err == nil {
		r.Data(204, []byte("Created"))
	} else {
		r.Data(500, []byte(err.Error()))
	}
}

func postCertificates(req *http.Request, params martini.Params, r render.Render) {

	csrString := req.PostFormValue("csr")
	format := req.URL.Query().Get("format")

	csr, err := pkix.NewCertificateRequestFromPEM([]byte(csrString))
	if err != nil {
		panic(err)
	}

	newCA, err := ca.NewCA(config["root-dir"])
	if err != nil {
		panic(err)
	}

	cert, err := newCA.IssueCertificate(csr)
	if err != nil {
		panic(err)
	}

	certPem, err := cert.ToPEM()
	if err != nil {
		panic(err)
	}
	if format == "file" {
		r.Data(200, certPem)
	} else {
		r.JSON(200, map[string]interface{}{
			"certificate": map[string]interface{}{
				"id":  cert.GetSerialNumber().Int64(),
				"crt": string(certPem),
				//"csr": csr,
			},
		})
	}
}

func getCA(req *http.Request, params martini.Params, r render.Render) {

	format := req.URL.Query().Get("format")

	newCA, err := ca.NewCA(config["root-dir"])
	if err != nil {
		panic(err)
	}

	pem, err := newCA.Certificate.ToPEM()
	if err != nil {
		panic(err)
	}

	if format == "file" {
		r.Data(200, pem)
	} else {
		r.JSON(200, map[string]interface{}{
			"ca": map[string]interface{}{
				"crt": string(pem),
			},
		})
	}
}

func routeGetAdAsset(r render.Render, res http.ResponseWriter, req *http.Request, params martini.Params) {
	slot := params["slot"]
	id := params["id"]
	ad := getAd(req, slot, id)
	if ad == nil {
		r.JSON(404, map[string]string{"error": "not_found"})
		return
	}
	content_type := "application/octet-stream"
	if ad.Type != "" {
		content_type = ad.Type
	}

	res.Header().Set("Content-Type", content_type)
	data, _ := rd.Get(assetKey(slot, id)).Result()

	range_str := req.Header.Get("Range")
	if range_str == "" {
		r.Data(200, []byte(data))
		return
	}

	re := regexp.MustCompile("^bytes=(\\d*)-(\\d*)$")
	m := re.FindAllStringSubmatch(range_str, -1)

	if m == nil {
		r.Status(416)
		return
	}

	head_str := m[0][1]
	tail_str := m[0][2]

	if head_str == "" && tail_str == "" {
		r.Status(416)
		return
	}

	head := 0
	tail := 0

	if head_str != "" {
		head, _ = strconv.Atoi(head_str)
	}
	if tail_str != "" {
		tail, _ = strconv.Atoi(tail_str)
	} else {
		tail = len(data) - 1
	}

	if head < 0 || head >= len(data) || tail < 0 {
		r.Status(416)
		return
	}

	range_data := data[head:(tail + 1)]
	content_range := fmt.Sprintf("bytes %d-%d/%d", head, tail, len(data))
	res.Header().Set("Content-Range", content_range)
	res.Header().Set("Content-Length", strconv.Itoa(len(range_data)))

	r.Data(206, []byte(range_data))
}

func downloadHandler(render render.Render, params martini.Params) {
	dat, _ := ioutil.ReadFile("./upload/" + params["id"])
	render.Data(200, dat)
}