Marko Tikvić / webutility

Browse Code »

Commit e1fbb41f916dcaa9b5440a16cb5a0268a43ca18c

Authored by Marko Tikvić 2016-11-30 12:28:11 +0100

1 parent c2ed249111

Exists in master and in 1 other branch

added comments

Showing 7 changed files with 65 additions and 26 deletions Show diff stats

auth_utility.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"errors"
 	"time"
 	"crypto/sha256"
 	"crypto/rand"
 	"encoding/hex"
 	"strings"
 	"github.com/dgrijalva/jwt-go"
 )
 const OneDay   = time.Hour*24
 const OneWeek  = OneDay*7
 const saltSize = 32
 const appName  = "korisnicki-centar"
 const secret   = "korisnicki-centar-api"
 type TokenClaims struct {
 	Username string `json:"username"`
 	Role     string `json:"role"`
 	jwt.StandardClaims
 }
 type CredentialsStruct struct {
 	Username string `json:"username"`
 	Password string `json:"password"`
 }
+// generateSalt returns a random string of 'saltSize' length to be used for hashing.
 func generateSalt() (salt string, err error) {
 	rawsalt := make([]byte, saltSize)
 	_, err = rand.Read(rawsalt)
 	if err != nil {
 		return "", err
 	}
 	salt = hex.EncodeToString(rawsalt)
 	return salt, nil
 }
+// HashString hashes input string with SHA256 algorithm.
+// If the presalt parameter is not provided HashString will generate new salt string.
 func HashString(str string, presalt string) (hash, salt string, err error) {
 	// chech if message is presalted
 	if presalt == "" {
 		salt, err = generateSalt()
 		if err != nil {
 			return "", "", err
 		}
 	} else {
 		salt = presalt
 	}
 	// convert strings to raw byte slices
 	rawstr := []byte(str)
 	rawsalt, err := hex.DecodeString(salt)
 	if err != nil {
 		return "", "", err
 	}
 	rawdata := make([]byte, len(rawstr) + len(rawsalt))
 	rawdata = append(rawdata, rawstr...)
 	rawdata = append(rawdata, rawsalt...)
 	// hash message + salt
 	hasher := sha256.New()
 	hasher.Write(rawdata)
 	rawhash := hasher.Sum(nil)
 	hash = hex.EncodeToString(rawhash)
 	return hash, salt, nil
 }
+// CreateAPIToken creates JWT token encoding username, role,
+// expiration date and issuer claims in it.
 func CreateAPIToken(username, role string) (string, error) {
 	var apiToken string
 	var err error
 	if err != nil {
 		return "", err
 	}
 	claims := TokenClaims{
 		username,
 		role,
 		jwt.StandardClaims{
 			ExpiresAt: (time.Now().Add(OneWeek)).Unix(),
 			Issuer:    appName,
 		},
 	}
 	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	apiToken, err = jwtToken.SignedString([]byte(secret))
 	if err != nil {
 		return "", err
 	}
 	return apiToken, nil
 }
+// RefreshAPIToken prolongs JWT token's expiration date.
 func RefreshAPIToken(tokenString string) (string, error) {
 	var newToken string
 	tokenString = strings.TrimPrefix(tokenString, "Bearer ")
-	token, err := parseTokenFunc(tokenString)
+	token, err := jwt.ParseWithClaims(tokenString, &TokenClaims{}, secretFunc)
 	if err != nil {
 		return "", err
 	}
 	// type assertion
 	claims, ok := token.Claims.(*TokenClaims)
 	if !ok || !token.Valid {
 		return "", errors.New("token is not valid")
 	}
 	claims.ExpiresAt = (time.Now().Add(OneWeek)).Unix()
 	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	newToken, err = jwtToken.SignedString([]byte(secret))
 	if err != nil {
 		return "", err
 	}
 	return newToken, nil
 }
+// ParseAPIToken parses JWT token claims.
 func ParseAPIToken(tokenString string) (*TokenClaims, error) {
-	if ok := strings.HasPrefix(tokenString, "Bearer"); ok {
+	if ok := strings.HasPrefix(tokenString, "Bearer "); ok {
 		tokenString = strings.TrimPrefix(tokenString, "Bearer ")
 	} else {
 		return &TokenClaims{}, errors.New("Authorization header is incomplete")
 	}
-	token, err := parseTokenFunc(tokenString)
+	token, err := jwt.ParseWithClaims(tokenString, &TokenClaims{}, secretFunc)
 	if err != nil {
 		return &TokenClaims{}, err
 	}
 	// type assertion
 	claims, ok := token.Claims.(*TokenClaims)
 	if !ok || !token.Valid {
 		return &TokenClaims{}, errors.New("token is not valid")
 	}
 	return claims, nil
 }
-func parseTokenFunc(tokenString string) (*jwt.Token, error) {
+// secretFunc returns byte slice of 'secret'.
-	token, err := jwt.ParseWithClaims(tokenString,
+func secretFunc(token *jwt.Token) (interface{}, error) {
-		&TokenClaims{},
+	return []byte(secret), nil
-		func(token *jwt.Token) (interface{}, error) {
-			return []byte(secret), nil

format_utility.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"time"
 	"fmt"
 )
+// UnixToDate converts given Unix time to local time in format and returns result:
+// YYYY-MM-DD hh:mm:ss +zzzz UTC
 func UnixToDate(unix int64) time.Time {
 	return time.Unix(unix, 0)
 }
+// DateToUnix converts given date in Unix timestamp.
 func DateToUnix(date interface{}) int64 {
 	if date != nil {
 		t := date.(time.Time)
 		return t.Unix()
 	}
 	return 0
 }
+// EqualQuotes encapsulates given string in SQL 'equal' statement and returns result.
+// Example: "hello" -> " = 'hello'"
 func EqualQuotes(stmt string) string {
 	if stmt != "" {
 		stmt = fmt.Sprintf(" = '%s'", stmt)
 	}
 	return stmt
 }
+// LikeQuotes encapsulates given string in SQL 'like' statement and returns result.
+// Example: "hello" -> " LIKE UPPER('%hello%')"
 func LikeQuotes(stmt string) string {
 	if stmt != "" {
 		stmt = fmt.Sprintf(" LIKE UPPER('%s%s%s')", "%", stmt, "%")
 	}
 	return stmt
 }

http_utility.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"net/http"
 	"encoding/json"
 )
 const templateHttpErr500_EN = "An internal server error has occurred."
 const templateHttpErr500_RS = "Došlo je do greške na serveru."
 const templateHttpErr400_EN = "Bad request: invalid request body."
 const templateHttpErr400_RS = "Neispravan zahtev."
 const templateHttpErr401_EN = "Unauthorized request."
 const templateHttpErr401_RS = "Neautorizovan zahtev."
 type httpError struct {
 	Error   []HttpErrorDesc `json:"error"`
 	Request string          `json:"request"`
 }
 type HttpErrorDesc struct {
 	Lang string `json:"lang"`
 	Desc string `json:"description"`
 }
+// ErrorResponse writes HTTP error to w.
 func ErrorResponse(w http.ResponseWriter, r *http.Request, code int, desc []HttpErrorDesc) {
 	err := httpError{ desc, r.Method + " " + r.URL.Path }
 	w.WriteHeader(code)
 	json.NewEncoder(w).Encode(err)
 }
+// BadRequestResponse writes HTTP error 400 to w.
 func BadRequestResponse(w http.ResponseWriter, req *http.Request) {
 	ErrorResponse(w, req, http.StatusBadRequest, []HttpErrorDesc{
 		{ "en", templateHttpErr400_EN },
 		{ "rs", templateHttpErr400_RS },
 	})
 }
+// InternalSeverErrorResponse writes HTTP error 500 to w.
 func InternalServerErrorResponse(w http.ResponseWriter, req *http.Request) {
 	ErrorResponse(w, req, http.StatusInternalServerError, []HttpErrorDesc{
 		{ "en", templateHttpErr500_EN },
 		{ "rs", templateHttpErr500_RS },
 	})
 }
+// UnauthorizedError writes HTTP error 401 to w.
 func UnauthorizedResponse(w http.ResponseWriter, req *http.Request) {
 	ErrorResponse(w, req, http.StatusUnauthorized, []HttpErrorDesc{
 		{ "en", templateHttpErr500_EN },
 		{ "rs", templateHttpErr500_RS },
 	})
 }
 // TODO: Check for content type
-// Sets common headers and checks for token validity.
+// Sets common headers, checks for token validity and performs access control.
 func WrapHandler(handlerFunc http.HandlerFunc, auth bool) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods",
 			"POST, GET, PUT, DELETE, OPTIONS")
 		w.Header().Set("Access-Control-Allow-Headers",
 			`Accept, Content-Type, Content-Length,
 			Accept-Encoding, X-CSRF-Token, Authorization`)
 		w.Header().Set("Content-Type", "application/json; charset=utf-8")
 		if req.Method == "OPTIONS" {
 			return
 		}
 		if auth {
 			token := req.Header.Get("Authorization")
 			if _, err := ParseAPIToken(token); err != nil {
 				UnauthorizedResponse(w, req)
 				return
 			}
 		}
 		err := req.ParseForm()
 		if err != nil {
 			BadRequestResponse(w, req)
 			return
 		}
 		// execute HandlerFunc
 		handlerFunc(w, req)
 	}
 }
+// NotFoundHandler writes HTTP error 404 to w.
 func NotFoundHandler(w http.ResponseWriter, req *http.Request) {
 	ErrorResponse(w, req, http.StatusNotFound, []HttpErrorDesc{
 		{ "en", "Not found." },
 		{ "rs", "Traženi resurs ne postoji." },
 	})
 }

json_utility.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"net/http"
 	"encoding/json"
 	"errors"
 	"gopkg.in/rana/ora.v3"
 	"io"
 	"io/ioutil"
 	"sync"
 )
 var mu = &sync.Mutex{}
 var allPayloads []payloadBuff
 type LangMap map[string]map[string]string
 type Field struct {
 	Parameter  string `json:"param"`
 	Type       string `json:"type"`
 	Visible    bool   `json:"visible"`
 	Editable   bool   `json:"editable"`
 }
 type CorrelationField struct {
 	Result   string   `json:"result"`
 	Elements []string `json:"elements"`
 	Type     string   `json:"type"`
 }
 type Translation struct {
 	Language     string            `json:"language"`
 	FieldsLabels map[string]string `json:"fieldsLabels"`
 }
-// Field 'Type' is not required in payload.
-// 'payloadBuff' type is only a bridge between ORACLE CLOB and 'Payload' type.
 type payloadBuff struct {
 	Type         string             `json:"tableType"`
 	Method	     string             `json:"method"`
 	Params	     map[string]string  `json:"params"`
 	Lang	     []Translation      `json:"lang"`
 	Fields	     []Field            `json:"fields"`
 	Correlations []CorrelationField `json:"correlationFields"`
 	IdField      string             `json:"idField"`
 	// Data can only hold slices of any type. It can't be used for itteration
 	Data	     interface{}        `json:"data"`
 }
 type Payload struct {
 	Method	     string             `json:"method"`
 	Params	     map[string]string  `json:"params"`
 	Lang	     []Translation      `json:"lang"`
 	Fields	     []Field            `json:"fields"`
 	Correlations []CorrelationField `json:"correlationFields"`
 	IdField      string             `json:"idField"`
 	// Data can only hold slices of any type. It can't be used for itteration
 	Data	     interface{}        `json:"data"`
 }
+// NewPayload returs payload for provided table.
 func NewPayload(r *http.Request, table string) Payload {
 	var pload Payload
 	pload.Method = r.Method + " " + r.URL.Path
 	if table != "" {
 		pload.Params = make(map[string]string, 0)
 		pload.Lang = loadTranslations(table)
 		pload.Fields = loadFields(table)
 		pload.IdField = loadIdField(table)
 		pload.Correlations = loadCorrelations(table)
 	}
 	return pload
 }
+// DeliverPayload writes payload to w.
 func DeliverPayload(w http.ResponseWriter, payload Payload) {
 	json.NewEncoder(w).Encode(payload)
 	payload.Data = nil
 }
+// loadTranslations loads translations for a payload of the given data type.
 func loadTranslations(id string) []Translation {
 	translations := make([]Translation, 0)
 	for _, pload := range allPayloads {
 		if pload.Type == id {
 			for _, t := range pload.Lang {
 				//translations[t.Language] = t.FieldsLabels
 				translations = append(translations, Translation{
 					Language: t.Language,
 					FieldsLabels: t.FieldsLabels,
 				})
 			}
 		}
 	}
 	return translations
 }
+// loadFields loads fields for a payload of the given data type.
 func loadFields(id string) []Field {
 	fields := make([]Field, 0)
 	for _, pload := range allPayloads {
 		if pload.Type == id{
 			for _, f := range pload.Fields {
 				fields = append(fields, f)
 			}
 		}
 	}
 	return fields
 }
+// loadIdField loads ID field for a payload of the given data type.
 func loadIdField(id string) string {
 	for _, pload := range allPayloads {
 		if pload.Type == id {
 			return pload.IdField
 		}
 	}
 	return ""
 }
+// loadCorrelations loads correlations field for a payload of the given data type.
 func loadCorrelations(id string) []CorrelationField {
 	resp := make([]CorrelationField, 0)
 	for _, pload := range allPayloads {
 		if pload.Type == id {
 			for _, f := range pload.Correlations {
 				resp = append(resp, f)
 			}
 		}
 	}
 	return resp
 }
+// InitTables loads all payloads in the memory.
 func InitTables(db *ora.Ses, project string) error {
 	jsonbuf, _ := fetchJSON(db, EqualQuotes(project))
 	mu.Lock()
 	defer mu.Unlock()
 	json.Unmarshal(jsonbuf, &allPayloads)
 	if len(allPayloads) == 0 {
 		return errors.New("tables config is corrupt")
 	}
 	return nil
 }
+// fetchJSON fetches JSON configuration file from TABLES_CONFIG table.
 func fetchJSON(db *ora.Ses, project string) ([]byte, error) {
 	stmt, err := db.Prep(`SELECT
 		JSON_CLOB
 		FROM TABLES_CONFIG
 		WHERE PROJEKAT` + project, ora.S)
 	defer stmt.Close()
 	if err != nil {
 		return nil, err
 	}
 	rset, err := stmt.Qry()
 	if err != nil {
 		return nil, err
 	}
 	bytes := make([]byte, 0)
 	if rset.Next() {
 		lob := rset.Row[0].(io.Reader)
 		bytes, err = ioutil.ReadAll(lob)
 		if err != nil {
 			// Ignore for now, it's some weird streaming read/write LOB error.
 			// TODO: Find a fix for this.
 			//return nil, err
 		}
 	}
 	return bytes, nil
 }
+// DecodeJSON decodes JSON data from r to v and returns any error
+// that happens during decoding process.

list_config.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"gopkg.in/rana/ora.v3"
 )
 type ListOptions struct {
 	GlobalFilter  bool   `json:"globalFilter"`
 	LocalFilters  bool   `json:"localFilters"`
 	RemoteFilters bool   `json:"remoteFilters"`
 	Pagination    bool   `json:"pagination"`
 	PageSize      uint64 `json:"pageSize"`
 	Pivot         bool   `json:"pivot"`
 	Detail        bool   `json:"detail"`
 	Total         bool   `json:"total"`
 }
 type ListFilter struct {
 	Position       uint32   `json:"-"`
 	ObjectType     string   `json:"-"`
 	FiltersField   string   `json:"filtersField"`
 	DefaultValues  string   `json:"defaultValues"`
 	FiltersType    string   `json:"filtersType"`
 	FiltersLabel   string   `json:"filtersLabel"`
 	DropdownConfig Dropdown `json:"dropdownConfig"`
 }
 type Dropdown struct {
 	ObjectType   string `json:"objectType"`
 	FiltersField string `json:"filtersField"`
-	IdField      string `json:"idField"`
+	IDField      string `json:"idField"`
 	LabelField   string `json:"labelField"`
 }
 type ListGraph struct {
 	ObjectType string `json:"objectType"`
 	X string          `json:"xField"`
 	Y string          `json:"yField"`
 	GroupField string `json:"groupField"`
 	Label string      `json:"label"`
 }
 type ListActions struct {
 	Create bool `json:"create"`
 	Update bool `json:"update"`
 	Delete bool `json:"delete"`
 	Export bool `json:"export"`
 	Print  bool `json:"print"`
 	Graph  bool `json:"graph"`
 }
 type ListNavNode struct {
 	ObjectType       string `json:"objectType"`
 	LabelField       string `json:"label"`
 	Icon             string `json:"icon"`
 	ParentObjectType string `json:"parentObjectType"`
-	ParentIdField    string `json:"parentIdField"`
+	ParentIDField    string `json:"parentIdField"`
 }
 type ListParentNode struct {
 	ObjectType  string `json:"objectType"`
 	LabelField  string `json:"labelField"`
 	FilterField string `json:"filterField"`
 }
 type ListPivot struct {
 	ObjectType    string `json:"objectType"`
 	GroupField    string `json:"groupField"`
 	DistinctField string `json:"distinctField"`
 	Value         string `json:"valueField"`
 }
 type ListDetails struct {
 	ObjectType        string `json:"objectType"`
 	ParentObjectType  string `json:"parentObjectType"`
 	ParentFilterField string `json:"parentFilterField"`
 	SingleDetail      bool   `json:"singleDetail"`
 }
 type ListConfig struct {
 	ObjectType string           `json:"objectType"`
 	Title      string           `json:"title"`
 	LazyLoad   bool             `json:"lazyLoad"`
 	InlineEdit bool             `json:"inlineEdit"`
 	Options    ListOptions      `json:"options"`
 	Filters    []ListFilter     `json:"defaultFilters"`
 	Graphs     []ListGraph      `json:"graphs"`
 	Actions    ListActions      `json:"actions"`
 	Parent     []ListParentNode `json:"parent"`
 	Navigation []ListNavNode    `json:"navigation"`
 	Pivots     []ListPivot      `json:"pivots"`
 	Details    ListDetails      `json:"details"`
 }
+// GetListConfig returns list configuration for the given object type for the front-end application.
 func GetListConfig(db *ora.Ses, objType string) (ListConfig, error) {
-	resp := NewDefaultList(objType)
+	resp := newDefaultList(objType)
 	var err error
 	err = setListParams(db, &resp, objType)
 	resp.Navigation, err = getListNavigation(db, objType)
 	resp.Actions, err = getListActions(db, objType)
 	resp.Filters, err = getListFilters(db, objType)
 	resp.Options, err = getListOptions(db, objType)
 	resp.Parent, err = getListParent(db, objType)
 	resp.Graphs, err = getListGraph(db, objType)
 	resp.Pivots, err = getListPivot(db, objType)
 	resp.Details, err = getListDetails(db, objType)
 	if err != nil {
 		return ListConfig{}, err
 	}
 	return resp, nil
 }
-func GetListConfigObjectIdField(db *ora.Ses, otype string) string {
+// GetListConfigObjectIDField returns ID field for the given object type.
+func GetListConfigObjectIDField(db *ora.Ses, otype string) string {
 	var resp string
 	var err error
 	var stmt *ora.Stmt
 	stmt, err = db.Prep(`SELECT
 		ID_FIELD
 		FROM LIST_CONFIG_ID_FIELD
 		WHERE OBJECT_TYPE = '` + otype + `'`,
 		ora.S)
 	defer stmt.Close()
 	if err != nil {
 		return ""
 	}
 	rset, err := stmt.Qry()
 	if rset.Next() {
 		resp = rset.Row[0].(string)
 	}
 	if rset.Err != nil {
 		return ""
 	}
 	return resp
 }
-func NewDefaultList(objType string) ListConfig {
+// newDefaultList returns default configuration for the given object type.
+func newDefaultList(objType string) ListConfig {
 	list := ListConfig{
 		ObjectType: objType,
 		Title: objType,
 		LazyLoad: false,
 		Options: ListOptions{
 			GlobalFilter: true,
 			LocalFilters: true,
 			RemoteFilters: false,
 			Pagination: true,
 			PageSize: 20,
 		},
 		Filters: nil,
 		Actions: ListActions{
 			Create: false,
 			Update: false,
 			Delete: false,
 			Export: false,
 			Print: false,
 			Graph: false,
 		},
 		Parent: nil,
 		Navigation: nil,
 	}
 	return list
 }
+// setListParams sets the default parameters of the provided configuration list for the given object type.
 func setListParams(db *ora.Ses, list *ListConfig, objType string) error {
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		OBJECT_TYPE, TITLE, LAZY_LOAD, INLINE_EDIT
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.U32, ora.U32)
 	if err != nil {
 		return err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return err
 	}
 	if rset.Next() {
 		otype := rset.Row[0].(string)
 		if otype != "" {
 			list.ObjectType = otype
 		}
 		title := rset.Row[1].(string)
 		if title != "" {
 			list.Title = title
 		}
 		list.LazyLoad = rset.Row[2].(uint32) != 0
 		list.InlineEdit = rset.Row[3].(uint32) != 0
 	}
 	if rset.Err != nil {
 		return rset.Err
 	}
 	return nil
 }
+// getListNavigation returns list navigation node slice for the given objectType.
 func getListNavigation(db *ora.Ses, listObjType string) ([]ListNavNode, error) {
 	resp := make([]ListNavNode, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		a.OBJECT_TYPE, a.PARENT_OBJECT_TYPE, a.LABEL, a.ICON, b.PARENT_ID_FIELD, b.RB
 		FROM LIST_CONFIG_NAVIGATION b
 		JOIN LIST_CONFIG_CHILD a ON b.PARENT_CHILD_ID = a.PARENT_CHILD_ID
 		WHERE b.LIST_OBJECT_TYPE = '`+listObjType+`'
 		ORDER BY b.RB ASC`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	for rset.Next() {
 		resp = append(resp, ListNavNode{
 			ObjectType: rset.Row[0].(string),
 			ParentObjectType: rset.Row[1].(string),
 			LabelField: rset.Row[2].(string),
 			Icon: rset.Row[3].(string),
-			ParentIdField: rset.Row[4].(string),
+			ParentIDField: rset.Row[4].(string),
 		})
 	}
 	if rset.Err != nil {
 		return nil, rset.Err
 	}
 	return resp, nil
 }
+// getListActions returns list actions for the given objectType.
 func getListActions(db *ora.Ses, objType string) (ListActions, error) {
 	var resp ListActions
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		ACTION_CREATE, ACTION_UPDATE, ACTION_DELETE, ACTION_EXPORT,
 		ACTION_PRINT, ACTION_GRAPH
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.U32, ora.U32, ora.U32, ora.U32,
 		ora.U32, ora.U32)
 	if err != nil {
 		return ListActions{}, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return ListActions{}, err
 	}
 	if rset.Next() {
 		resp.Create = rset.Row[0].(uint32) != 0
 		resp.Update = rset.Row[1].(uint32) != 0
 		resp.Delete = rset.Row[2].(uint32) != 0
 		resp.Export = rset.Row[3].(uint32) != 0
 		resp.Print = rset.Row[4].(uint32) != 0
 		resp.Graph = rset.Row[5].(uint32) != 0
 	}
 	if rset.Err != nil {
 		return ListActions{}, rset.Err
 	}
 	return resp, nil
 }
+// getListFiters returns list filter slice for the given object type.
 func getListFilters(db *ora.Ses, objType string) ([]ListFilter, error) {
 	resp := make([]ListFilter, 0)
 	filtersFields, err := getFilterFieldsAndPosition(db, objType)
 	if err != nil {
 		return nil, err
 	}
 	for field, pos := range filtersFields {
 		filters, _ := getFiltersByFilterField(db, field)
 		for _, filter := range filters {
 			var f ListFilter
 			f.Position = pos
 			f.ObjectType = objType
 			f.FiltersField = field
 			f.DefaultValues = filter.DefaultValues
 			f.FiltersLabel = filter.Label
 			f.FiltersType = filter.Type
 			if filter.Type == "dropdown" {
 				f.DropdownConfig, err = getFilterDropdownConfig(db, field)
 				if err != nil {
 					return nil, err
 				}
 			}
 			resp = append(resp, f)
 		}
 	}
 	sortFilters(resp)
 	return resp, nil
 }
+// getFilterFieldsAndPosition returns a map of filter fields and their respective position in the menu.
 func getFilterFieldsAndPosition(db *ora.Ses, objType string) (map[string]uint32, error) {
 	filtersField := make(map[string]uint32, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		FILTERS_FIELD, RB
 		FROM LIST_CONFIG_FILTERS
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.U32)
 	if err != nil {
 		return nil, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return nil, err
 	}
 	for rset.Next() {
 		filtersField[rset.Row[0].(string)] = rset.Row[1].(uint32)
 	}
 	if rset.Err != nil {
 		return nil, rset.Err
 	}
 	return filtersField, nil
 }
 type _filter struct {
 	DefaultValues string
 	Label         string
 	Type          string
 }
+// getFiltersByFilterField returns filter slice for the given filter field.
 func getFiltersByFilterField(db *ora.Ses, filtersField string) ([]_filter, error) {
 	resp := make([]_filter, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		FILTERS_TYPE, FILTERS_LABEL, DEFAULT_VALUES
 		FROM LIST_FILTERS_FIELD
 		WHERE FILTERS_FIELD = '` + filtersField + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	for rset.Next() {
 		resp = append(resp, _filter{
 			Type: rset.Row[0].(string),
 			Label: rset.Row[1].(string),
 			DefaultValues: rset.Row[2].(string),
 		})
 	}
 	if rset.Err != nil {
 		return resp, rset.Err
 	}
 	return resp, nil
 }
+// getFilterDropdownConfig returns dropdown menu for the given filter field.
 func getFilterDropdownConfig(db *ora.Ses, filtersField string) (Dropdown, error) {
 	var resp Dropdown
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		FILTERS_FIELD, OBJECT_TYPE, ID_FIELD, LABEL_FIELD
 		FROM LIST_DROPDOWN_FILTER
 		WHERE FILTERS_FIELD = '` + filtersField + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	if rset.Next() {
 		resp.FiltersField = rset.Row[0].(string)
 		resp.ObjectType = rset.Row[1].(string)
-		resp.IdField = rset.Row[2].(string)
+		resp.IDField = rset.Row[2].(string)
 		resp.LabelField = rset.Row[3].(string)
 	}
 	if rset.Err != nil {
 		return resp, rset.Err
 	}
 	return resp, nil
 }
+// sortFilters bubble sorts provided filters slice by position field.
 func sortFilters(filters []ListFilter) {
 	done := false
 	var temp ListFilter
 	for !done {
 		done = true
 		for i := 0; i < len(filters) - 1; i++ {
 			if filters[i].Position > filters[i+1].Position {
 				done = false
 				temp = filters[i]
 				filters[i] = filters[i+1]
 				filters[i+1] = temp
 			}
 		}
 	}
 }
+// getListGraph return list graph slice for the given object type.
 func getListGraph(db *ora.Ses, objType string) ([]ListGraph, error) {
 	resp := make([]ListGraph, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		OBJECT_TYPE, X_FIELD, Y_FIELD, GROUP_FIELD, LABEL
 		FROM LIST_GRAPHS
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	for rset.Next() {
 		resp = append(resp, ListGraph{
 			ObjectType: rset.Row[0].(string),
 			X: rset.Row[1].(string),
 			Y: rset.Row[2].(string),
 			GroupField: rset.Row[3].(string),
 			Label: rset.Row[4].(string),
 		})
 	}
 	if rset.Err != nil {
 		return resp, rset.Err
 	}
 	return resp, nil
 }
+// getListOptions returns list options for the given object type.
 func getListOptions(db *ora.Ses, objType string) (ListOptions, error) {
 	var resp ListOptions
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		GLOBAL_FILTER, LOCAL_FILTER, REMOTE_FILTER, PAGINATION,
 		PAGE_SIZE, PIVOT, DETAIL, TOTAL
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.U32, ora.U32, ora.U32, ora.U32,
 		ora.U64, ora.U64, ora.U32, ora.U32)
 	if err != nil {
 		return ListOptions{}, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return ListOptions{}, err
 	}
 	if rset.Next() {
 		resp.GlobalFilter = rset.Row[0].(uint32) != 0
 		resp.LocalFilters = rset.Row[1].(uint32) != 0
 		resp.RemoteFilters = rset.Row[2].(uint32) != 0
 		resp.Pagination = rset.Row[3].(uint32) != 0
 		resp.PageSize = rset.Row[4].(uint64)
 		resp.Pivot = rset.Row[5].(uint64) != 0
 		resp.Detail = rset.Row[6].(uint32) != 0
 		resp.Total = rset.Row[7].(uint32) != 0
 	}
 	if rset.Err != nil {
 		return ListOptions{}, rset.Err
 	}
 	return resp, nil
 }
+// getListParent returns list parent node slice for the given object type.
 func getListParent(db *ora.Ses, objType string) ([]ListParentNode, error) {
 	resp := make([]ListParentNode, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		PARENT_OBJECT_TYPE, PARENT_LABEL_FIELD, PARENT_FILTER_FIELD
 		FROM LIST_CONFIG_CHILD
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	for rset.Next() {
 		resp = append(resp, ListParentNode{
 			ObjectType: rset.Row[0].(string),
 			LabelField: rset.Row[1].(string),
 			FilterField: rset.Row[2].(string),
 		})
 	}
 	if rset.Err != nil {
 		return nil, rset.Err
 	}
 	return resp, nil
 }
+// getListPivot list pivot slice for the given object type.
 func getListPivot(db *ora.Ses, objType string) ([]ListPivot, error) {
 	resp := make([]ListPivot, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		OBJECT_TYPE, GROUP_FIELD, DISTINCT_FIELD, VALUE_FIELD
 		FROM LIST_PIVOTS
 		WHERE OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.S)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	for rset.Next() {
 		resp = append(resp, ListPivot{
 			ObjectType: rset.Row[0].(string),
 			GroupField: rset.Row[1].(string),
 			DistinctField: rset.Row[2].(string),
 			Value: rset.Row[3].(string),
 		})
 	}
 	if rset.Err != nil {
 		return nil, rset.Err
 	}
 	return resp, nil
 }
+// getListDetails returns list details for the given object type.
 func getListDetails(db *ora.Ses, objType string) (ListDetails, error) {
 	var resp ListDetails
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT
 		OBJECT_TYPE, PARENT_OBJECT_TYPE, PARENT_FILTER_FIELD, SINGLE_DETAIL
 		FROM LIST_CONFIG_DETAIL
 		WHERE PARENT_OBJECT_TYPE = '` + objType + `'`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.U32)
 	if err != nil {
 		return resp, err
 	}
 	defer stmt.Close()
 	rset, err := stmt.Qry()
 	if err != nil {
 		return resp, err
 	}
 	if rset.Next() {
 		resp.ObjectType = rset.Row[0].(string)
 		resp.ParentObjectType = rset.Row[1].(string)
 		resp.ParentFilterField = rset.Row[2].(string)
 		resp.SingleDetail = rset.Row[3].(uint32) != 0
 	}
 	if rset.Err != nil {
 		return resp, rset.Err
 	}
 	return resp, nil
 }

select_config.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"gopkg.in/rana/ora.v3"
 )
 type SelectConfig struct {
 	ListObjType string `json:"listObjectType"`
 	ObjType     string `json:"objectType"`
 	Type        string `json:"type"`
 	IdField     string `json:"idField"`
 	LabelField  string `json:"labelField"`
 	ValueField  string `json:"valueField"`
 }
+// GetSelectConfig returns select configuration slice for the given object type.
 func GetSelectConfig(db *ora.Ses, otype string) ([]SelectConfig, error) {
 	resp := make([]SelectConfig, 0)
 	var err error
 	var stmt *ora.Stmt
 	query := `SELECT a.LIST_OBJECT_TYPE, a.OBJECT_TYPE, a.ID_FIELD,
 		a.LABEL_FIELD, a.TYPE, b.FIELD
 		FROM LIST_SELECT_CONFIG a, LIST_VALUE_FIELD b
 		WHERE a.LIST_OBJECT_TYPE` + otype + `
 		AND b.LIST_TYPE = a.LIST_OBJECT_TYPE
 		AND b.OBJECT_TYPE = a.OBJECT_TYPE`
 	stmt, err = db.Prep(query, ora.S, ora.S, ora.S, ora.S, ora.S, ora.S)
 	defer stmt.Close()
 	if err != nil {
 		return nil, err
 	}
 	rset, err := stmt.Qry()
 	if err != nil {
 		return nil, err
 	}
 	for rset.Next() {
 		resp = append(resp, SelectConfig{
 			ListObjType: rset.Row[0].(string),
 			ObjType: rset.Row[1].(string),
 			IdField: rset.Row[2].(string),
 			LabelField: rset.Row[3].(string),
 			Type: rset.Row[4].(string),
 			ValueField: rset.Row[5].(string),
 		})
 	}
 	if rset.Err != nil {
 		return nil, rset.Err
 	}
 	return resp, nil
 }

sql_sequrity.go

Diff comments View file @e1fbb41

 package webutility
 import (
 	"strings"
 )
 var patern string = "\"';&*<>=\\`:"
-func SQLSafeString(s string) string {
+// SQLSafeString removes characters from s found in patern and returns new modified string.
+func SQLSafeString(s string) (safe string) {
 	for _, c := range patern {
-		s = strings.Replace(s, string(c), "", -1)
+		safe = strings.Replace(s, string(c), "", -1)
 	}
-	return s
+	return safe
 }