Example #1
0
func ExecTemplate(c *TemplateConfig) error {
	templatesMutex.Lock()
	defer templatesMutex.Unlock()

	cname := ""
	for i, name := range c.Names {
		c.Names[i] = filepath.Join(c.Dir, name+".html")
		cname += name
	}

	t, ok := templatesCache[cname]
	if !ok || appengine.IsDevAppServer() {
		var err error
		t = template.New(cname).Delims(c.LeftDelim, c.RightDelim)

		t, err = t.Funcs(templatesFuncs).ParseFiles(c.Names...)
		if err != nil {
			return errors.New(err)
		}
		templatesCache[cname] = t
	}

	if err := t.ExecuteTemplate(c.W, "base", c.Data); err != nil {
		return errors.New(err)
	}

	return nil
}
Example #2
0
// Load the request data using gorilla schema into a struct
func (r *Request) LoadData(data interface{}) error {
	if err := r.Req.ParseForm(); err != nil {
		return errors.New(err)
	}

	if err := schemaDecoder.Decode(data, r.Req.Form); err != nil {
		e, ok := err.(schema.MultiError)
		if ok {
			// Delete the invalid path errors
			for k, v := range e {
				if strings.Contains(v.Error(), "schema: invalid path") {
					delete(e, k)
				}
			}

			// Return directly if there are no other kind of errors
			if len(e) == 0 {
				return nil
			}
		}

		// Not a MultiError, log it
		if err != nil {
			return errors.New(err)
		}
	}

	return nil
}
Example #3
0
// Validate the form.
// Returns a boolean indicating if the data was valid according
// to the validations defined on f. It returns an error too.
func Validate(r *http.Request, f Form) (bool, error) {
	// Copy the body to a buffer so we can use it twice
	buf := new(bytes.Buffer)
	if _, err := buf.ReadFrom(r.Body); err != nil {
		return false, errors.New(err)
	}
	nbuf := ioutil.NopCloser(bytes.NewBuffer(buf.Bytes()))
	r.Body = nbuf

	m := make(map[string]interface{})
	if err := json.NewDecoder(buf).Decode(&m); err != nil {
		return false, errors.New(err)
	}

	fields := f.Fields()
	validations := f.Validations()
	for _, field := range fields {
		id := getId(field)
		if id == "" {
			continue
		}

		// Skip fields without validation constrainst
		if _, ok := validations[id]; !ok {
			continue
		}

		value := normalizeValue(id, m)
		for _, val := range validations[id] {
			if !val.Func(value) {
				return false, nil
			}
		}
		f.SetValue(id, value)
	}

	if err := json.NewDecoder(r.Body).Decode(f); err != nil {
		return false, errors.New(err)
	}

	return true, nil
}
Example #4
0
func (r *Request) EmitJson(data interface{}) error {
	// XSSI protection
	fmt.Fprintln(r.W, ")]}',")

	// Encode the output
	if err := json.NewEncoder(r.W).Encode(data); err != nil {
		return errors.New(err)
	}

	return nil
}
Example #5
0
func (r *Request) LoadJsonData(data interface{}) error {
	if err := json.NewDecoder(r.Req.Body).Decode(data); err != nil {
		if err == io.EOF {
			return nil
		}

		return errors.New(err)
	}

	return nil
}
Example #6
0
// Send a mail using the SendGrid API
func SendMail(c appengine.Context, mail *Mail) error {
	client := &http.Client{
		Transport: &urlfetch.Transport{
			Context:  c,
			Deadline: time.Duration(20) * time.Second,
		},
	}

	// Build the data needed for the API call
	data := url.Values{
		"api_user": []string{conf.MAIL_API_USER},
		"api_key":  []string{conf.MAIL_API_KEY},
		"to":       []string{mail.To},
		"toname":   []string{mail.ToName},
		"subject":  []string{mail.Subject},
		"html":     []string{mail.Html},
		"from":     []string{mail.From},
		"fromname": []string{mail.FromName},
	}

	// Request the SendGrid API
	resp, err := client.PostForm(conf.MAIL_SEND_API, data)
	if err != nil {
		return errors.New(err)
	}
	defer resp.Body.Close()

	// Decode the Mail API response
	var r mailAPI
	if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
		return errors.New(err)
	}

	// Test for errors in the api call
	if r.Message != "success" {
		return errors.Format("cannot send the mail: api %s message: %v",
			r.Message, r.Errors)
	}

	return nil
}
Example #7
0
func (r *Request) processError(err error) {
	e := errors.New(err).(*errors.Error)
	LogError(r.C, e)

	h, ok := errorHandlers[e.Code]
	if ok {
		if err := h(r); err == nil {
			return
		}
	}

	http.Error(r.W, "", e.Code)
}
Example #8
0
func LogError(c appengine.Context, err error) {
	e := errors.New(err).(*errors.Error)
	c.Errorf("%s", e.Error())
	sendErrorByEmail(c, e.Error())
}
Example #9
0
func (r *Request) JsonResponse(data interface{}) error {
	if err := json.NewEncoder(r.W).Encode(data); err != nil {
		return errors.New(err)
	}
	return nil
}