Golang revel.Response類代碼示例

func (r RrdFetchTsvResult) Apply(req *revel.Request, resp *revel.Response) {
	revel.TRACE.Printf("Apply start\n")
	resp.WriteHeader(http.StatusOK, "text/tab-separated-values")

	resp.Out.Write([]byte("date\tvalue\n"))
	data := r.data
	row := 0
	for ti := data.Start.Add(data.Step); ti.Before(data.End) || ti.Equal(data.End); ti = ti.Add(data.Step) {
		v := data.ValueAt(0, row)
		line := fmt.Sprintf("%d\t%e\n", ti.Unix(), v)
		resp.Out.Write([]byte(line))
		row++
	}
	revel.TRACE.Printf("Apply exit\n")
	/*
		origStep := r.origStep * 1000
		jStep := origStep / int(step)
		if jStep < 1 {
			jStep = 1
		}

		// TODO: Calculate max, average and such if jStep > 1
		revel.TRACE.Printf("jStep=%d, step=%d, origStep=%d\n", jStep, step, origStep)
		for j := 0; j < data.RowLen; j += jStep {
			t := start + int64(j + 1) * step
			v := data.ValueAt(0, j)
			if j > 0 && math.IsNaN(v) {
				break
			}
			line := fmt.Sprintf("%d\t%e\n", t, v)
			resp.Out.Write([]byte(line))
		}
	*/
}

// Custom responses -----------------------------------------------------------
// Custom response for image
func (r ImageResponse) Apply(req *revel.Request, resp *revel.Response) {

	// FIX:
	// If settings loaded out of actions then revel throws nil pointer, so we
	// load here the first time only
	if font == nil {
		fontPath, _ := revel.Config.String("gummyimage.fontpath")
		font, _ = gummyimage.LoadFont(fontPath)
	}

	resp.WriteHeader(http.StatusOK, "image/png")

	g, _ := gummyimage.NewDefaultGummy(r.sizeX, r.sizeY, r.bgColor)
	g.Font = font

	// Custom text?
	if len(r.text) == 0 {
		g.DrawTextSize(r.fgColor)
	} else {
		g.DrawTextCenter(r.text, r.fgColor)
	}

	b := new(bytes.Buffer)
	g.Get(r.format, b)
	resp.Out.Write(b.Bytes())
}

func (r dynamicImage) Apply(req *revel.Request, resp *revel.Response) {
	buffer := bytes.NewBufferString("digraph callgraph{\n")
	if r.searchType == "caller" {
		var visitedCallers = sort.StringSlice{r.funcName}
		callers, ok := allCallers[r.dataSource]
		if ok {
			r.calcCalls(&callers, r.funcName, 0, buffer, visitedCallers)
		}
	} else {
		var visitedCallees = sort.StringSlice{r.funcName}
		callees, ok := allCallees[r.dataSource]
		if ok {
			r.calcCalls(&callees, r.funcName, 0, buffer, visitedCallees)
		}
	}
	buffer.WriteString("}")

	/* set direction */
	param0 := "-Grankdir=" + r.direction
	cmdDot := exec.Command("dot", param0, "-Tpng")
	cmdDot.Stdin = bytes.NewReader(buffer.Bytes())

	output, err := cmdDot.Output()
	if err != nil {
		resp.WriteHeader(http.StatusOK, "text/html")
		resp.Out.Write([]byte("No image: " + err.Error()))
		return
	}

	resp.WriteHeader(http.StatusOK, "image/png")
	resp.Out.Write(output)
}

// Render the Templates into the Response, handles errors and panics using the
// same mechanisms of revel.
func (r *RenderLayoutTemplateResult) Apply(req *revel.Request, resp *revel.Response) {
	// Handle panics when rendering templates.
	defer func() {
		if err := recover(); err != nil {
			revel.ERROR.Println(err)
			revel.PlaintextErrorResult{fmt.Errorf("Template Execution Panic in %s:\n%s",
				r.Template.Name(), err)}.Apply(req, resp)
		}
	}()

	chunked := revel.Config.BoolDefault("results.chunked", false)
	r.RenderTmpl[""] = r.Template
	r.RenderArgs["ContentForItems"] = r.RenderTmpl

	// If it's a HEAD request, throw away the bytes.
	out := io.Writer(resp.Out)
	if req.Method == "HEAD" {
		out = ioutil.Discard
	}

	// In a prod mode, write the status, render, and hope for the best.
	// (In a dev mode, always render to a temporary buffer first to avoid having
	// error pages distorted by HTML already written)
	if chunked && !revel.DevMode {
		resp.WriteHeader(http.StatusOK, "text/html")
		if r.Layout == nil {
			r.render(req, resp, out)
		} else {
			r.renderWithLayout(req, resp, out)
		}
		return
	}

	// Render the template into a temporary buffer, to see if there was an error
	// rendering the template.  If not, then copy it into the response buffer.
	// Otherwise, template render errors may result in unpredictable HTML (and
	// would carry a 200 status code)
	var b bytes.Buffer
	if r.Layout == nil {
		r.render(req, resp, &b)
	} else {
		r.renderWithLayout(req, resp, &b)
	}

	if !chunked {
		resp.Out.Header().Set("Content-Length", strconv.Itoa(b.Len()))
	}
	resp.WriteHeader(http.StatusOK, "text/html")
	b.WriteTo(out)
}

func (r FResponse404) Apply(req *revel.Request, resp *revel.Response) {
	var b []byte
	var err error
	if revel.Config.BoolDefault("results.pretty", false) {
		b, err = json.MarshalIndent(r.obj, "", "  ")
	} else {
		b, err = json.Marshal(r.obj)
	}

	if err != nil {
		revel.ErrorResult{Error: err}.Apply(req, resp)
		return
	}

	resp.WriteHeader(http.StatusNotFound, "application/json")
	resp.Out.Write(b)
}

func (r *RenderLayoutTemplateResult) renderError(req *revel.Request, resp *revel.Response, err error) {
	var templateContent []string
	templateName, line, description := parseTemplateError(err)
	if templateName == "" {
		templateName = r.Layout.Name()
		templateContent = r.Layout.Content()
	} else {
		if tmpl, err := revel.MainTemplateLoader.Template(templateName); err == nil {
			templateContent = tmpl.Content()
		}
	}
	compileError := &revel.Error{
		Title:       "Layout Execution Error",
		Path:        templateName,
		Description: description,
		Line:        line,
		SourceLines: templateContent,
	}
	resp.Status = 500
	revel.ERROR.Printf("Template Execution Error (in %s): %s", templateName, description)
	revel.ErrorResult{r.RenderArgs, compileError}.Apply(req, resp)
}

func (r RssXml) Apply(req *revel.Request, resp *revel.Response) {
	resp.WriteHeader(http.StatusOK, "application/xml")
	resp.Out.Write([]byte(r))
}

// This will get called for Cert/Key downloads to manage HTTP Headers
func (r Download) Apply(req *revel.Request, resp *revel.Response) {
	resp.WriteHeader(http.StatusOK, "text/plain") //Browser can open
	//resp.WriteHeader(http.StatusOK, "application/text")//Forces Browser to download
	resp.Out.Write([]byte(r))
}

func (r LoginResult) Apply(req *revel.Request, resp *revel.Response) {
	resp.WriteHeader(r.StatusCode, "text/html")
	resp.Out.Write([]byte(r.Message))
}

func (r HTML) Apply(req *revel.Request, resp *revel.Response) {
	resp.WriteHeader(http.StatusOK, "text/html")
	resp.Out.Write([]byte(r))
}

// Set HTTP header types for returning image(not html page)
func (r JPGImage) Apply(req *revel.Request, resp *revel.Response) {
	// Output screenshot
	resp.WriteHeader(http.StatusOK, "image/jpg")
	resp.Out.Write(r)
}

func (u Utf8Result) Apply(req *revel.Request, resp *revel.Response) {
	resp.WriteHeader(resp.Status, "text/plain; charset=utf-8")
	resp.Out.Write([]byte(u))
}

// Marshals the Responder instance as the body response as Json.
// The Responder's implementation of GetHttpStatus() will be used
// as the Http status code in the response.
// The Responder's implementation of GetErroLogString() will be used
// to log to revel.Error.
func (r JsonErrorResult) Apply(req *revel.Request, resp *revel.Response) {
	responseData, _ := json.Marshal(r.Responder)
	resp.WriteHeader((*r.Responder).GetHttpStatus(), "application/json")
	resp.Out.Write(responseData)
	revel.ERROR.Printf("Error response: HTTP-%d : %s", (*r.Responder).GetHttpStatus(), (*r.Responder).GetErroLogString())
}