forms

package module
v0.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 30, 2023 License: MIT Imports: 10 Imported by: 0

README

Forms

GoDoc

Forms is a lightweight, but incredibly useful go library for parsing form data from an http.Request. It supports multipart forms, url-encoded forms, json data, and url query parameters. It also provides helper methods for converting data into other types and a Validator object which can be used to validate the data. Forms is framework-agnostic and works directly with the http package.

Version 0.4.0

Development Status

Forms is no longer actively maintained, and therefore it is not recommended for use in mission-critical production applications at this time. That said, it is fairly well tested and is probably fine to use for low-traffic hobby sites.

Forms follows semantic versioning but offers no guarantees of backwards compatibility until version 1.0. Keep in mind that breaking changes might occur. We will do our best to make the community aware of any non-trivial breaking changes beforehand. We recommend using a dependency vendoring tool such as godep to ensure that breaking changes will not break your application.

Installation

Install like you would any other package:

go get github.com/albrow/forms

Then include the package in your import statements:

import "github.com/albrow/forms"

Example Usage

Meant to be used inside the body of an http.HandlerFunc or any function that has access to an http.Request.

func CreateUserHandler(res http.ResponseWriter, req *http.Request) {
	// Parse request data.
	userData, err := forms.Parse(req)
	if err != nil {
		// Handle err
		// ...
	}

	// Validate
	val := userData.Validator()
	val.Require("username")
	val.LengthRange("username", 4, 16)
	val.Require("email")
	val.MatchEmail("email")
	val.Require("password")
	val.MinLength("password", 8)
	val.Require("confirmPassword")
	val.Equal("password", "confirmPassword")
	val.RequireFile("profileImage")
	val.AcceptFileExts("profileImage", "jpg", "png", "gif")
	if val.HasErrors() {
		// Write the errors to the response
		// Maybe this means formatting the errors as json
		// or re-rendering the form with an error message
		// ...
	}

	// Use data to create a user object
	user := &models.User {
		Username: userData.Get("username"),
		Email: userData.Get("email"),
		HashedPassword: hash(userData.Get("password")),
	}

	// Continue by saving the user to the database and writing
	// to the response
	// ...


	// Get the contents of the profileImage file
	imageBytes, err := userData.GetFileBytes("profileImage")
	if err != nil {
	  // Handle err
	}
	// Now you can either copy the file over to your server using io.Copy,
	// upload the file to something like amazon S3, or do whatever you want
	// with it.
}

Contributing

See CONTRIBUTING.md

License

Forms is licensed under the MIT License. See the LICENSE file for more information.

Documentation

Overview

package forms is a lightweight, but incredibly useful library for parsing form data from an http.Request. It supports multipart forms, url-encoded forms, json data, and url query parameters. It also provides helper methods for converting data into other types and a Validator object which can be used to validate the data. Forms is framework-agnostic and works directly with the http package.

For the full source code, example usage, and more, visit https://github.com/albrow/forms.

Version 0.4.0

Index

Examples

Constants

View Source
const DefaultMaxFormSize = 500000

DefaultMaxFormSize is the default maximum form size (in bytes) used by the Parse function.

Variables

This section is empty.

Functions

This section is empty.

Types

type Data

type Data struct {
	// Values holds any basic key-value string data
	// This includes all fields from a json body or
	// urlencoded form, and the form fields only (not
	// files) from a multipart form
	Values url.Values
	// UrlParams holds query params from query string
	QueryParams map[string]string
	// Files holds files from a multipart form only.
	// For any other type of request, it will always
	// be empty. Files only supports one file per key,
	// since this is by far the most common use. If you
	// need to have more than one file per key, parse the
	// files manually using req.MultipartForm.File.
	Files map[string]*multipart.FileHeader
	// contains filtered or unexported fields
}

Data holds data obtained from the request body and url query parameters. Because Data is built from multiple sources, sometimes there will be more than one value for a given key. You can use Get, Set, Add, and Del to access the first element for a given key or access the Values and Files properties directly to access additional elements for a given key. You can also use helper methods to convert the first value for a given key to a different type (e.g. bool or int).

func CreateFromMap

func CreateFromMap(m map[string]string) *Data

CreateFromMap returns a Data object with keys and values matching the map.

func Parse

func Parse(req *http.Request) (*Data, error)

Parse uses the default max form size defined above and calls ParseMax

Example
// Construct a request object for example purposes only.
// Typically you would be using this inside a http.HandlerFunc,
// not constructing your own request.
req, _ := http.NewRequest("GET", "/", nil)
values := url.Values{}
values.Add("name", "Bob")
values.Add("age", "25")
values.Add("retired", "false")
req.PostForm = values
req.Header.Set("Content-Type", "form-urlencoded")

// Parse the form data.
data, err := Parse(req)
if err != nil {
	panic(err)
}
name := data.Get("name")
age := data.GetInt("age")
retired := data.GetBool("retired")
if retired {
	fmt.Printf("%s is %d years old and he has retired.", name, age)
} else {
	fmt.Printf("%s is %d years old and not yet retired.", name, age)
}
Output:

Bob is 25 years old and not yet retired.

func ParseMax

func ParseMax(req *http.Request, max int64) (*Data, error)

ParseMax parses the request body and url query parameters into Data. The content in the body of the request has a higher priority, will be added to Data first, and will be the result of any operation which gets the first element for a given key (e.g. Get, GetInt, or GetBool).

func (*Data) Add

func (d *Data) Add(key string, value string)

Add adds the value to key. It appends to any existing values associated with key.

func (*Data) AddFile

func (d *Data) AddFile(key string, file *multipart.FileHeader)

AddFile adds the multipart form file to data with the given key.

func (*Data) AddQueryParam

func (d *Data) AddQueryParam(key string, value string)

func (Data) BindJSON

func (d Data) BindJSON(v interface{}) error

BindJSON binds v to the json data in the request body. It calls json.Unmarshal and sets the value of v.

func (*Data) Del

func (d *Data) Del(key string)

Del deletes the values associated with key.

func (*Data) DelFile

func (d *Data) DelFile(key string)

DelFile deletes the file associated with key (if any). If there is no file associated with key, it does nothing.

func (*Data) DelQueryParam

func (d *Data) DelQueryParam(key string)

Del deletes the values associated with key.

func (*Data) Encode

func (d *Data) Encode() string

Encode encodes the values into “URL encoded” form ("bar=baz&foo=quux") sorted by key. Any files in d will be ignored because there is no direct way to convert a file to a URL encoded value.

func (Data) FileExists

func (d Data) FileExists(key string) bool

FileExists returns true iff data.Files[key] exists. When parsing a request body, the key is considered to be in existence if it was provided in the request body, even if the file is empty.

func (Data) Get

func (d Data) Get(key string) string

Get gets the first value associated with the given key. If there are no values associated with the key, Get returns the empty string. To access multiple values, use the map directly.

func (Data) GetAndUnmarshalJSON

func (d Data) GetAndUnmarshalJSON(key string, v interface{}) error

GetAndUnmarshalJSON assumes that the first element in data[key] is a json string and attempts to unmarshal it into v. If unmarshaling was not successful, returns an error. v should be a pointer to some data structure.

func (Data) GetBool

func (d Data) GetBool(key string) bool

GetBool returns the first element in data[key] converted to a bool.

func (Data) GetBytes

func (d Data) GetBytes(key string) []byte

GetBytes returns the first element in data[key] converted to a slice of bytes.

func (Data) GetFile

func (d Data) GetFile(key string) *multipart.FileHeader

GetFile returns the multipart form file associated with key, if any, as a *multipart.FileHeader. If there is no file associated with key, it returns nil. If you just want the body of the file, use GetFileBytes.

func (Data) GetFileBytes

func (d Data) GetFileBytes(key string) ([]byte, error)

GetFileBytes returns the body of the file associated with key. If there is no file associated with key, it returns nil (not an error). It may return an error if there was a problem reading the file. If you need to know whether or not the file exists (i.e. whether it was provided in the request), use the FileExists method.

func (Data) GetFloat

func (d Data) GetFloat(key string) float64

GetFloat returns the first element in data[key] converted to a float.

func (Data) GetInt

func (d Data) GetInt(key string) int

GetInt returns the first element in data[key] converted to an int.

func (Data) GetJson

func (d Data) GetJson() []byte

func (Data) GetMapFromJSON

func (d Data) GetMapFromJSON(key string) (map[string]interface{}, error)

GetMapFromJSON assumes that the first element in data[key] is a json string, attempts to unmarshal it into a map[string]interface{}, and if successful, returns the result. If unmarshaling was not successful, returns an error.

func (Data) GetQueryParam

func (d Data) GetQueryParam(key string) string

func (Data) GetSliceFromJSON

func (d Data) GetSliceFromJSON(key string) ([]interface{}, error)

GetSliceFromJSON assumes that the first element in data[key] is a json string, attempts to unmarshal it into a []interface{}, and if successful, returns the result. If unmarshaling was not successful, returns an error.

func (Data) GetStringsSplit

func (d Data) GetStringsSplit(key string, delim string) []string

GetStringsSplit returns the first element in data[key] split into a slice delimited by delim.

func (Data) GetXML

func (d Data) GetXML() []byte

func (Data) KeyExists

func (d Data) KeyExists(key string) bool

KeyExists returns true iff data.Values[key] exists. When parsing a request body, the key is considered to be in existence if it was provided in the request body, even if its value is empty.

func (Data) QueryParamExists

func (d Data) QueryParamExists(key string) bool

func (*Data) Set

func (d *Data) Set(key string, value string)

Set sets the key to value. It replaces any existing values.

func (*Data) SetQueryParam

func (d *Data) SetQueryParam(key string, value string)

Set sets the key to value. It replaces any existing values.

func (*Data) Validator

func (d *Data) Validator() *Validator

Validator returns a Validator which can be used to easily validate data.

type ValidationResult

type ValidationResult struct {
	Ok bool
	// contains filtered or unexported fields
}

ValidationResult is returned from every validation method and can be used to override the default field name or error message. If you want to use the default fields and messages, simply discard the ValidationResult.

func (*ValidationResult) Field

func (vr *ValidationResult) Field(field string) *ValidationResult

Field changes the field name associated with the validation result.

func (*ValidationResult) Message

func (vr *ValidationResult) Message(msg string) *ValidationResult

Message changes the error message associated with the validation result. msg should typically be a user-readable sentence, such as "username is required."

type Validator

type Validator struct {
	// contains filtered or unexported fields
}

Validator has methods for validating its underlying Data. A Validator stores any errors that occurred during validation, and they can be accessed directly. In a typical workflow, you will create a Validator from some Data, call some methods on that validator (e.g. Require), check if the validator has errors, then do something with the errors if it does.

Example
// Construct a request object for example purposes only.
// Typically you would be using this inside a http.HandlerFunc,
// not constructing your own request.
req, _ := http.NewRequest("GET", "/", nil)
values := url.Values{}
values.Add("name", "Bob")
values.Add("age", "25")
req.PostForm = values
req.Header.Set("Content-Type", "form-urlencoded")

// Parse the form data.
data, _ := Parse(req)

// Validate the data.
val := data.Validator()
val.Require("name")
val.MinLength("name", 4)
val.Require("age")

// Here's how you can change the error message or field name
val.Require("retired").Field("retired_status").Message("Must specify whether or not person is retired.")

// Check for validation errors and print them if there are any.
if val.HasErrors() {
	fmt.Printf("%#v\n", val.Messages())
}
Output:

[]string{"name must be at least 4 characters long.", "Must specify whether or not person is retired."}

func (*Validator) AcceptFileExts

func (v *Validator) AcceptFileExts(field string, exts ...string) *ValidationResult

AcceptFileExts will add an error to the Validator if the extension of the file identified by field is not in exts. exts should be one ore more allowed file extensions, not including the preceding ".". If the file does not exist, it does not add an error to the Validator.

func (*Validator) AddError

func (v *Validator) AddError(field string, msg string) *ValidationResult

AddError adds an error associated with field to the validator. msg should typically be a user-readable sentence, such as "username is required."

func (*Validator) Equal

func (v *Validator) Equal(field1 string, field2 string) *ValidationResult

Equal will add an error to the Validator if data[field1] is not equal to data[field2].

func (*Validator) ErrorMap

func (v *Validator) ErrorMap() map[string][]string

ErrorMap reutrns all the fields and error messages for the validator in the form of a map. The keys of the map are field names, and the values are any error messages associated with that field name.

func (*Validator) Fields

func (v *Validator) Fields() []string

Fields returns the fields for all validation results for the Validator, in order.

func (*Validator) Greater

func (v *Validator) Greater(field string, value float64) *ValidationResult

Greater will add an error to the Validator if the first element of data.Values[field] is not greater than value or if the first element of data.Values[field] cannot be converted to a number.

func (*Validator) GreaterOrEqual

func (v *Validator) GreaterOrEqual(field string, value float64) *ValidationResult

GreaterOrEqual will add an error to the Validator if the first element of data.Values[field] is not greater than or equal to value or if the first element of data.Values[field] cannot be converted to a number.

func (*Validator) HasErrors

func (v *Validator) HasErrors() bool

HasErrors returns true iff the Validator has errors, i.e. if any validation methods called on the Validator failed.

func (*Validator) LengthRange

func (v *Validator) LengthRange(field string, min int, max int) *ValidationResult

LengthRange will add an error to the Validator if data.Values[field] is shorter than min (if data.Values[field] has less than min characters) or if data.Values[field] is longer than max (if data.Values[field] has more than max characters), not counting leading or trailing whitespace.

func (*Validator) Less

func (v *Validator) Less(field string, value float64) *ValidationResult

Less will add an error to the Validator if the first element of data.Values[field] is not less than value or if the first element of data.Values[field] cannot be converted to a number.

func (*Validator) LessOrEqual

func (v *Validator) LessOrEqual(field string, value float64) *ValidationResult

LessOrEqual will add an error to the Validator if the first element of data.Values[field] is not less than or equal to value or if the first element of data.Values[field] cannot be converted to a number.

func (*Validator) Match

func (v *Validator) Match(field string, regex *regexp.Regexp) *ValidationResult

Match will add an error to the Validator if data.Values[field] does not match the regular expression regex.

func (*Validator) MatchEmail

func (v *Validator) MatchEmail(field string) *ValidationResult

MatchEmail will add an error to the Validator if data.Values[field] does not match the formatting expected of an email.

func (*Validator) MaxLength

func (v *Validator) MaxLength(field string, length int) *ValidationResult

MaxLength will add an error to the Validator if data.Values[field] is longer than length (if data.Values[field] has more than length characters), not counting leading or trailing whitespace.

func (*Validator) Messages

func (v *Validator) Messages() []string

Messages returns the messages for all validation results for the Validator, in order.

func (*Validator) MinLength

func (v *Validator) MinLength(field string, length int) *ValidationResult

MinLength will add an error to the Validator if data.Values[field] is shorter than length (if data.Values[field] has less than length characters), not counting leading or trailing whitespace.

func (*Validator) Require

func (v *Validator) Require(field string) *ValidationResult

Require will add an error to the Validator if data.Values[field] does not exist, is an empty string, or consists of only whitespace.

func (*Validator) RequireFile

func (v *Validator) RequireFile(field string) *ValidationResult

RequireFile will add an error to the Validator if data.Files[field] does not exist or is an empty file

func (*Validator) TypeBool

func (v *Validator) TypeBool(field string) *ValidationResult

TypeBool will add an error to the Validator if the first element of data.Values[field] cannot be converted to a bool.

func (*Validator) TypeFloat

func (v *Validator) TypeFloat(field string) *ValidationResult

TypeFloat will add an error to the Validator if the first element of data.Values[field] cannot be converted to an float64.

func (*Validator) TypeInt

func (v *Validator) TypeInt(field string) *ValidationResult

TypeInt will add an error to the Validator if the first element of data.Values[field] cannot be converted to an int.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL