Marko Tikvić / webutility

Browse Code »

Commit 707782344fd94987d3cd7c8426d674dd6d7b16a1

Authored by Marko Tikvić 2019-03-07 13:21:49 +0100

1 parent 954ce8ddd9

Exists in master

lint; vet

Showing 12 changed files with 186 additions and 120 deletions Show diff stats

auth.go

Diff comments View file @7077823

 package webutility
 import (
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"net/http"
 	"strings"
 	"time"
 	"github.com/dgrijalva/jwt-go"
 )
 var _issuer = "webutility"
 var _secret = "webutility"
 // TokenClaims are JWT token claims.
 type TokenClaims struct {
 	// extending a struct
 	jwt.StandardClaims
 	// custom claims
 	Token     string `json:"access_token"`
 	TokenType string `json:"token_type"`
 	Username  string `json:"username"`
 	RoleName  string `json:"role"`
 	RoleID    int64  `json:"role_id"`
 	ExpiresIn int64  `json:"expires_in"`
 }
+// InitJWT ...
 func InitJWT(issuer, secret string) {
 	_issuer = issuer
 	_secret = secret
 }
 // ValidateHash hashes pass and salt and returns comparison result with resultHash
 func ValidateHash(pass, salt, resultHash string) (bool, error) {
 	hash, _, err := CreateHash(pass, salt)
 	if err != nil {
 		return false, err
 	}
 	res := hash == resultHash
 	return res, nil
 }
 // CreateHash hashes str using SHA256.
 // If the presalt parameter is not provided CreateHash will generate new salt string.
 // Returns hash and salt strings or an error if it fails.
 func CreateHash(str, presalt string) (hash, salt string, err error) {
 	// chech if message is presalted
 	if presalt == "" {
 		salt, err = randomSalt()
 		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
 }
 // CreateAuthToken returns JWT token with encoded username, role, expiration date and issuer claims.
 // It returns an error if it fails.
 func CreateAuthToken(username string, roleName string, roleID int64) (TokenClaims, error) {
 	t0 := (time.Now()).Unix()
 	t1 := (time.Now().Add(time.Hour * 24 * 7)).Unix()
 	claims := TokenClaims{
 		TokenType: "Bearer",
 		Username:  username,
 		RoleName:  roleName,
 		RoleID:    roleID,
 		ExpiresIn: t1 - t0,
 	}
 	// initialize jwt.StandardClaims fields (anonymous struct)
 	claims.IssuedAt = t0
 	claims.ExpiresAt = t1
 	claims.Issuer = _issuer
 	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	token, err := jwtToken.SignedString([]byte(_secret))
 	if err != nil {
 		return TokenClaims{}, err
 	}
 	claims.Token = token
 	return claims, nil
 }
 // RefreshAuthToken returns new JWT token with same claims contained in tok but with prolonged expiration date.
 // It returns an error if it fails.
 func RefreshAuthToken(tok string) (TokenClaims, error) {
 	token, err := jwt.ParseWithClaims(tok, &TokenClaims{}, secretFunc)
 	if err != nil {
 		if validation, ok := err.(*jwt.ValidationError); ok {
 			// don't return error if token is expired
 			// just extend it
 			if !(validation.Errors&jwt.ValidationErrorExpired != 0) {
 				return TokenClaims{}, err
 			}
 		} else {
 			return TokenClaims{}, err
 		}
 	}
 	// type assertion
 	claims, ok := token.Claims.(*TokenClaims)
 	if !ok {
 		return TokenClaims{}, errors.New("token is not valid")
 	}
 	// extend token expiration date
 	return CreateAuthToken(claims.Username, claims.RoleName, claims.RoleID)
 }
+// AuthCheck ...
 func AuthCheck(req *http.Request, roles string) (*TokenClaims, error) {
 	// validate token and check expiration date
 	claims, err := GetTokenClaims(req)
 	if err != nil {
 		return claims, err
 	}
 	if roles == "" {
 		return claims, nil
 	}
 	// check if token has expired
 	if claims.ExpiresAt < (time.Now()).Unix() {
 		return claims, errors.New("token has expired")
 	}
 	if roles == "*" {
 		return claims, nil
 	}
 	parts := strings.Split(roles, ",")
-	for i, _ := range parts {
+	for i := range parts {
 		r := strings.Trim(parts[i], " ")
 		if claims.RoleName == r {
 			return claims, nil
 		}
 	}
 	return claims, nil
 }
 // GetTokenClaims extracts JWT claims from Authorization header of req.
 // Returns token claims or an error.
 func GetTokenClaims(req *http.Request) (*TokenClaims, error) {
 	// check for and strip 'Bearer' prefix
 	var tokstr string
 	authHead := req.Header.Get("Authorization")
 	if ok := strings.HasPrefix(authHead, "Bearer "); ok {
 		tokstr = strings.TrimPrefix(authHead, "Bearer ")
 	} else {
 		return &TokenClaims{}, errors.New("authorization header in incomplete")
 	}
 	token, err := jwt.ParseWithClaims(tokstr, &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
 }
 // randomSalt returns a string of 32 random characters.
 func randomSalt() (s string, err error) {
 	const saltSize = 32
 	rawsalt := make([]byte, saltSize)
 	_, err = rand.Read(rawsalt)
 	if err != nil {
 		return "", err
 	}
 	s = hex.EncodeToString(rawsalt)
 	return s, nil
 }
 // secretFunc returns byte slice of API secret keyword.
 func secretFunc(token *jwt.Token) (interface{}, error) {
 	return []byte(_secret), nil
 }

default_values.go

Diff comments View file @7077823

 package webutility
+// Int32ValueOrDefault ...
 func Int32ValueOrDefault(val *interface{}) (def int32) {
 	if *val != nil {
 		def = (*val).(int32)
 	}
 	return def
 }
+// Int64ValueOrDefault ...
 func Int64ValueOrDefault(val *interface{}) (def int64) {
 	if *val != nil {
 		def = (*val).(int64)
 	}
 	return def
 }
+// Uint32ValueOrDefault ...
 func Uint32ValueOrDefault(val *interface{}) (def uint32) {
 	if *val != nil {
 		def = (*val).(uint32)
 	}
 	return def
 }
+// Uint64ValueOrDefault ...
 func Uint64ValueOrDefault(val *interface{}) (def uint64) {
 	if *val != nil {
 		def = (*val).(uint64)
 	}
 	return def
 }
+// Float32ValueOrDefault ...
 func Float32ValueOrDefault(val *interface{}) (def float32) {
 	if *val != nil {
 		def = (*val).(float32)
 	}
 	return def
 }
+// Float64ValueOrDefault ...
 func Float64ValueOrDefault(val *interface{}) (def float64) {
 	if *val != nil {
 		return (*val).(float64)
 	}
 	return def
 }
+// StringValueOrDefault ...
 func StringValueOrDefault(val *interface{}) (def string) {
 	if *val != nil {
 		def = (*val).(string)
 	}
 	return def
 }

email.go

Diff comments View file @7077823

1	package webutility	1	package webutility
2		2
3	// TODO(markO): test test test test test (and open source?)	3	// TODO(markO): test test test test test (and open source?)
4		4
5	import (	5	import (
6	"crypto/tls"	6	"crypto/tls"
7	"errors"	7	"errors"
8	"fmt"	8	"fmt"
9	"net/smtp"	9	"net/smtp"
10	"strings"	10	"strings"
11	)	11	)
12		12
		13	// Email ...
13	type Email struct {	14	type Email struct {
14	To []string	15	recipients []string
15	From string	16	sender string
16	Subject string	17	subject string
17	Body string	18	body string
18		19
19	config *EmailConfig	20	config *EmailConfig
20	}	21	}
21		22
		23	// NewEmail ...
22	func NewEmail() *Email {	24	func NewEmail() *Email {
23	return &Email{	25	return new(Email)
24	To: nil,	26	}
25	From: "",	27
26	Subject: "",	28	// EmailConfig ...
27	Body: "",	29	type EmailConfig struct {
28	config: nil,	30	ServerName string `json:"-"`
		31	Identity string `json:"-"`
		32	Username string `json:"username"`
		33	Password string `json:"password"`
		34	Host string `json:"host"`
		35	Port int `json:"port"`
		36	}
		37
		38	// NewEmailConfig ...
		39	func NewEmailConfig(ident, uname, pword, host string, port int) *EmailConfig {
		40	return &EmailConfig{
		41	ServerName: host + fmt.Sprintf(":%d", port),
		42	Identity: ident,
		43	Username: uname,
		44	Password: pword,
		45	Host: host,
		46	Port: port,
29	}	47	}
30	}	48	}
31		49
		50	// Config ...
32	func (e Email) Config(cfg EmailConfig) {	51	func (e Email) Config(cfg EmailConfig) {
33	e.config = cfg	52	e.config = cfg
34	}	53	}
35		54
36	func (e *Email) SetFrom(from string) {	55	// Sender ...
37	e.From = from	56	func (e *Email) Sender(from string) {
		57	e.sender = from
38	}	58	}
39		59
40	func (e *Email) SetTo(to []string) {	60	// AddRecipient ...
41	e.To = to	61	func (e *Email) AddRecipient(r string) {
		62	e.recipients = append(e.recipients, r)
42	}	63	}
43		64
44	func (e *Email) SetSubject(sub string) {	65	// Subject ...
45	e.Subject = sub	66	func (e *Email) Subject(sub string) {
		67	e.subject = sub
46	}	68	}
47		69
48	func (e *Email) SetBody(body string) {	70	func (e *Email) Write(body string) {
49	e.Body = body	71	e.body = body
50	}	72	}
51		73
52	func (e *Email) String() string {	74	func (e *Email) String() string {
53	var str strings.Builder	75	var str strings.Builder
54		76
55	str.WriteString("From:" + e.From + "\r\n")	77	str.WriteString("From:" + e.sender + "\r\n")
56		78
57	str.WriteString("To:")	79	str.WriteString("To:")
58	for i, _ := range e.To {	80	for i := range e.recipients {
59	if i > 0 {	81	if i > 0 {
60	str.WriteString(",")	82	str.WriteString(",")
61	}	83	}
62	str.WriteString(e.To[i])	84	str.WriteString(e.recipients[i])
63	}	85	}
64	str.WriteString("\r\n")	86	str.WriteString("\r\n")
65		87
66	str.WriteString("Subject:" + e.Subject + "\r\n")	88	str.WriteString("Subject:" + e.subject + "\r\n")
67		89
68	// body	90	// body
69	str.WriteString("\r\n" + e.Body + "\r\n")	91	str.WriteString("\r\n" + e.body + "\r\n")
70		92
71	return str.String()	93	return str.String()
72	}	94	}
73		95
		96	// Bytes ...
74	func (e *Email) Bytes() []byte {	97	func (e *Email) Bytes() []byte {
75	return []byte(e.String())	98	return []byte(e.String())
76	}	99	}
77		100
78	func (email *Email) Send() error {	101	// Send ...
79	if email.config == nil {	102	func (e *Email) Send() error {
		103	if e.config == nil {
80	return errors.New("email configuration not provided")	104	return errors.New("email configuration not provided")
81	}	105	}
82	conf := email.config	106	conf := e.config
83		107
84	c, err := smtp.Dial(conf.ServerName)	108	c, err := smtp.Dial(conf.ServerName)
85	if err != nil {	109	if err != nil {
86	return err	110	return err
87	}	111	}
88	defer c.Close()	112	defer c.Close()
89		113
90	// not sure if this is needed	114	/*
91	//if err = c.Hello(conf.ServerName); err != nil {	115	// not sure if this is needed
92	// return err	116	if err = c.Hello(conf.ServerName); err != nil {
93	//}	117	return err
		118	}
		119	*/
94		120
95	if ok, _ := c.Extension("STARTTLS"); ok {	121	if ok, _ := c.Extension("STARTTLS"); ok {
96	// disable stupid tls check for self-signed certificates	122	// disable stupid tls check for self-signed certificates
97	config := &tls.Config{	123	config := &tls.Config{
98	ServerName: conf.ServerName,	124	ServerName: conf.ServerName,
99	InsecureSkipVerify: true,	125	InsecureSkipVerify: true,
100	}	126	}
101	// for golang testing	127	/*
102	//if testHookStartTLS != nil {	128	// for golang testing
103	// testHookStartTLS(config)	129	if testHookStartTLS != nil {
104	//}	130	testHookStartTLS(config)
		131	}
		132	*/
105	if err = c.StartTLS(config); err != nil {	133	if err = c.StartTLS(config); err != nil {
106	return err	134	return err
107	}	135	}
108	}	136	}
109		137
110	/*	138	/*
111	// don't know what to do with this	139	// don't know what to do with this
112	if a != nil && c.ext != nil {	140	if a != nil && c.ext != nil {
113	if _, ok := c.ext["AUTH"]; !ok {	141	if _, ok := c.ext["AUTH"]; !ok {
114	return errors.New("smtp: server doesn't support AUTH")	142	return errors.New("smtp: server doesn't support AUTH")
115	}	143	}
116	if err = c.Auth(a); err != nil {	144	if err = c.Auth(a); err != nil {
117	return err	145	return err
118	}	146	}
119	}	147	}
120	*/	148	*/
121		149
122	// Set up authentication information.	150	// Set up authentication information.
123	auth := smtp.PlainAuth(conf.Identity, conf.Username, conf.Password, conf.Host)	151	auth := smtp.PlainAuth(conf.Identity, conf.Username, conf.Password, conf.Host)
124	if err = c.Auth(auth); err != nil {	152	if err = c.Auth(auth); err != nil {
125	return err	153	return err
126	}	154	}
127		155
128	if err = c.Mail(email.From); err != nil {	156	if err = c.Mail(e.sender); err != nil {
129	return err	157	return err
130	}	158	}
131		159
132	for _, addr := range email.To {	160	for _, addr := range e.recipients {
133	if err = c.Rcpt(addr); err != nil {	161	if err = c.Rcpt(addr); err != nil {
134	return err	162	return err
135	}	163	}
136	}	164	}
137		165
138	w, err := c.Data()	166	w, err := c.Data()
139	if err != nil {	167	if err != nil {
140	return err	168	return err
141	}	169	}
142		170
143	_, err = w.Write(email.Bytes())	171	_, err = w.Write(e.Bytes())
144	if err != nil {	172	if err != nil {
145	return err	173	return err
146	}	174	}
147		175
148	err = w.Close()	176	err = w.Close()
149	if err != nil {	177	if err != nil {
150	return err	178	return err
151	}	179	}
152		180
153	return c.Quit()	181	return c.Quit()
154	}	182	}
155

filtering.go

Diff comments View file @7077823

 package webutility
 import (
 	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
 )
+// Filter ...
 type Filter map[string][]string
+// Get ...
 func (f Filter) Get(key string) (values []string, ok bool) {
 	values, ok = f[key]
 	return values, ok
 }
+// Count ...
 func (f Filter) Count() int {
 	return len(f)
 }
+// Add ...
 func (f Filter) Add(key, val string) {
 	f[key] = append(f[key], val)
 }
+// ValueAt ...
 func (f Filter) ValueAt(val string, index int) string {
 	if filter, ok := f[val]; ok {
 		if len(filter) > index {
 			return filter[index]
 		}
 	}
 	return ""
 }
-func (fs Filter) validate(validFilters []string) (Filter, bool) {
+func (f Filter) validate(validFilters []string) (Filter, bool) {
 	goodFilters := make(Filter)
 	cnt, len := 0, 0
-	for f, _ := range fs {
+	for fi := range f {
 		len++
 		for _, v := range validFilters {
-			if f == v {
+			if fi == v {
 				cnt++
-				goodFilters[f] = fs[f]
+				goodFilters[fi] = f[fi]
 			}
 		}
 	}
 	result := true
 	if len > 0 && cnt == 0 {
 		// if no valid filters are found declare filtering request as invalid
 		result = false
 	}
 	return goodFilters, result
 }
-// requires input in format: "param1::value1|param2::value2..."
+// ParseFilters requires input in format: "param1::value1|param2::value2..."
 func ParseFilters(req *http.Request, header string) (filters Filter) {
 	q := req.FormValue(header)
 	q = strings.Trim(q, "\"")
 	kvp := strings.Split(q, "|")
 	filters = make(Filter, len(kvp))
-	for i, _ := range kvp {
+	for i := range kvp {
 		kv := strings.Split(kvp[i], "::")
 		if len(kv) == 2 {
 			key, _ := url.QueryUnescape(kv[0])
 			// get values (if more than 1)
 			vals := strings.Split(kv[1], ",")
 			for _, v := range vals {
 				u, _ := url.QueryUnescape(v)
 				filters[key] = append(filters[key], u)
 			}
 		}
 	}
 	return filters
 }
-// TODO(marko): very dodgy, needs more robustness
+// MakeFilterString is very dodgy, needs more robustness.
+// TODO(marko)
 func MakeFilterString(prefix string, filters Filter, validFilters []string) (res string, ok bool) {
 	if prefix != "" {
 		prefix += "."
 	}
 	if filters.Count() == 0 {
 		return "", true
 	}
 	filters, ok = filters.validate(validFilters)
 	if !ok {
 		return "", false
 	}
 	first := true
 	for k, filter := range filters {
 		symbol := "="
 		if first {
 			res += " where "
 			first = false
 		} else {
 			res += " and "
 		}
 		res += "("
 		for i, f := range filter {
 			if strings.HasPrefix(f, "<") || strings.HasPrefix(f, ">") || strings.HasPrefix(f, "!") {
 				symbol = string(f[0])
 				f = strings.TrimLeft(f, "<>!")
 				if strings.HasPrefix(f, "=") {
 					f = strings.TrimLeft(f, "=")
 					symbol += "="
 				}
 			}
 			res += fmt.Sprintf("%s%s %s '%s'", prefix, k, symbol, f)
 			if i < len(filter)-1 {
 				res += " or "
 			}
 		}
 		res += ")"
 	}
 	return res, ok
 }

format.go

Diff comments View file @7077823

 package webutility
 import (
 	"fmt"
 	"time"
 )
 // 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, ok := date.(time.Time)
 		if !ok {
 			return 0
 		}
 		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
 }
+// EqualString ...
 func EqualString(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.go

Diff comments View file @7077823

 package webutility
 import (
 	"encoding/json"
 	"fmt"
 	"net/http"
 )
+// StatusRecorder ...
 type StatusRecorder struct {
 	writer http.ResponseWriter
 	status int
 	size   int
 }
+// NewStatusRecorder ...
 func NewStatusRecorder(w http.ResponseWriter) *StatusRecorder {
 	return &StatusRecorder{
 		writer: w,
 		status: 0,
 		size:   0,
 	}
 }
-// http.ResponseWriter interface
+// WriteHeader is a wrapper http.ResponseWriter interface
 func (r *StatusRecorder) WriteHeader(code int) {
 	r.status = code
 	r.writer.WriteHeader(code)
 }
-// http.ResponseWriter interface
+// Write is a wrapper for http.ResponseWriter interface
 func (r *StatusRecorder) Write(in []byte) (int, error) {
 	r.size = len(in)
 	return r.writer.Write(in)
 }
-// http.ResponseWriter interface
+// Header is a wrapper for http.ResponseWriter interface
 func (r *StatusRecorder) Header() http.Header {
 	return r.writer.Header()
 }
+// Status ...
 func (r *StatusRecorder) Status() int {
 	return r.status
 }
+// Size ...
 func (r *StatusRecorder) Size() int {
 	return r.size
 }
 // NotFoundHandlerFunc writes HTTP error 404 to w.
 func NotFoundHandlerFunc(w http.ResponseWriter, req *http.Request) {
 	SetDefaultHeaders(w)
 	if req.Method == "OPTIONS" {
 		return
 	}
 	NotFound(w, req, fmt.Sprintf("Resource you requested was not found: %s", req.URL.String()))
 }
 // SetDefaultHeaders set's default headers for an HTTP response.
 func SetDefaultHeaders(w http.ResponseWriter) {
 	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")
 }
+// GetLocale ...
 func GetLocale(req *http.Request, dflt string) string {
 	loc := req.FormValue("locale")
 	if loc == "" {
 		return dflt
 	}
 	return loc
 }
-// 2xx
+// Success ...
 func Success(w http.ResponseWriter, payload interface{}, code int) {
 	w.WriteHeader(code)
 	if payload != nil {
 		json.NewEncoder(w).Encode(payload)
 	}
 }
-// 200
+// OK ...
 func OK(w http.ResponseWriter, payload interface{}) {
 	Success(w, payload, http.StatusOK)
 }
-// 201
+// Created ...
 func Created(w http.ResponseWriter, payload interface{}) {
 	Success(w, payload, http.StatusCreated)
 }
 type weberror struct {
 	Request string `json:"request"`
 	Error   string `json:"error"`
 }
-// 4xx; 5xx
+// Error ...
 func Error(w http.ResponseWriter, r *http.Request, code int, err string) {
 	werr := weberror{Error: err, Request: r.Method + " " + r.RequestURI}
 	w.WriteHeader(code)
 	json.NewEncoder(w).Encode(werr)
 }
-// 400
+// BadRequest ...
 func BadRequest(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusBadRequest, err)
 }
-// 401
+// Unauthorized ...
 func Unauthorized(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusUnauthorized, err)
 }
-// 403
+// Forbidden ...
 func Forbidden(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusForbidden, err)
 }
-// 404
+// NotFound ...
 func NotFound(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusNotFound, err)
 }
-// 409
+// Conflict ...
 func Conflict(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusConflict, err)
 }
-// 500
+// InternalServerError ...
 func InternalServerError(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusInternalServerError, err)
 }

list_config.go

Diff comments View file @7077823

 package webutility
 import (
 	"database/sql"
 	"fmt"
 )
+// ListOptions ...
 type ListOptions struct {
 	GlobalFilter  bool   `json:"globalFilter"`
 	LocalFilters  bool   `json:"localFilters"`
 	RemoteFilters bool   `json:"remoteFilters"`
 	Pagination    bool   `json:"pagination"`
 	PageSize      uint32 `json:"pageSize"`
 	Pivot         bool   `json:"pivot"`
 	Detail        bool   `json:"detail"`
 	Total         bool   `json:"total"`
 }
+// ListFilter ...
 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"`
 }
+// Dropdown ...
 type Dropdown struct {
 	ObjectType   string `json:"objectType"`
 	FiltersField string `json:"filtersField"`
 	IDField      string `json:"idField"`
 	LabelField   string `json:"labelField"`
 }
+// ListGraph ...
 type ListGraph struct {
 	ObjectType string `json:"objectType"`
 	X          string `json:"xField"`
 	Y          string `json:"yField"`
 	GroupField string `json:"groupField"`
 	Label      string `json:"label"`
 }
+// ListActions ...
 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"`
 	LiveGraph bool `json:"liveGraph"`
 	SaveFile  bool `json:"saveFile"`
 	ShowFile  bool `json:"showFile"`
 }
+// ListNavNode ...
 type ListNavNode struct {
 	ObjectType        string `json:"objectType"`
 	LabelField        string `json:"label"`
 	Icon              string `json:"icon"`
 	ParentObjectType  string `json:"parentObjectType"`
 	ParentIDField     string `json:"parentIdField"`
 	ParentFilterField string `json:"parentFilterField"`
 }
+// ListParentNode ...
 type ListParentNode struct {
 	ObjectType  string `json:"objectType"`
 	LabelField  string `json:"labelField"`
 	FilterField string `json:"filterField"`
 }
+// ListPivot ...
 type ListPivot struct {
 	ObjectType    string `json:"objectType"`
 	GroupField    string `json:"groupField"`
 	DistinctField string `json:"distinctField"`
 	Value         string `json:"valueField"`
 }
+// ListDetails ...
 type ListDetails struct {
 	ObjectType        string `json:"objectType"`
 	ParentObjectType  string `json:"parentObjectType"`
 	ParentFilterField string `json:"parentFilterField"`
 	SingleDetail      bool   `json:"singleDetail"`
 }
+// ListLiveGraph ...
 type ListLiveGraph struct {
 	ObjectType  string `json:"objectType"`
 	ValueFields string `json:"valueFields"`
 	LabelFields string `json:"labelFields"`
 }
+// ListConfig ...
 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"`
 	LiveGraph  ListLiveGraph    `json:"liveGraphs"`
 }
 // GetListConfig returns list configuration for the provided object type for the front-end application
 // or an error if it fails.
 func GetListConfig(db *sql.DB, objType string) (ListConfig, error) {
 	list := NewListConfig(objType)
 	err := list.setParams(db, objType)
 	err = list.SetNavigation(db, objType)
 	err = list.SetActions(db, objType)
 	err = list.SetFilters(db, objType)
 	err = list.SetOptions(db, objType)
 	err = list.SetParent(db, objType)
 	err = list.SetPivot(db, objType)
 	err = list.SetGraph(db, objType)
 	err = list.SetDetails(db, objType)
 	err = list.SetLiveGraph(db, objType)
 	if err != nil {
 		return list, err
 	}
 	return list, nil
 }
 // GetListConfigObjectIDField takes in database connection and an object type and it returns the
 // ID field name for the provided object type.
 func GetListConfigObjectIDField(db *sql.DB, otype string) string {
 	var resp string
 	rows, err := db.Query(`SELECT
 		ID_FIELD
 		FROM LIST_CONFIG_ID_FIELD
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", otype))
 	if err != nil {
 		return ""
 	}
 	defer rows.Close()
 	if rows.Next() {
 		rows.Scan(&resp)
 	}
 	if rows.Err() != nil {
 		return ""
 	}
 	return resp
 }
-// newDefaultList returns default configuration for the provided object type.
+// NewListConfig returns default configuration for the provided object type.
 func NewListConfig(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,
 			LiveGraph: false,
 		},
 		Parent:     nil,
 		Navigation: nil,
 	}
 	return list
 }
-// setListParams sets the default parameters of the provided configuration list for the provided object type.
+// setParams sets the default parameters of the provided configuration list for the provided object type.
 func (list *ListConfig) setParams(db *sql.DB, objType string) error {
 	rows, err := db.Query(`SELECT
 		OBJECT_TYPE,
 		TITLE,
 		LAZY_LOAD,
 		INLINE_EDIT
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if rows.Next() {
 		otype, title := "", ""
 		lazyLoad, inlineEdit := 0, 0
 		rows.Scan(&otype, &title, &lazyLoad, &inlineEdit)
 		if otype != "" {
 			list.ObjectType = otype
 		}
 		if title != "" {
 			list.Title = title
 		}
 		list.LazyLoad = lazyLoad != 0
 		list.InlineEdit = inlineEdit != 0
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// ListNavigation returns list navigation node slice for the provided objectType.
+// SetNavigation returns set's navigation nodes for listObjType object type.
 func (list *ListConfig) SetNavigation(db *sql.DB, listObjType string) error {
 	list.Navigation = make([]ListNavNode, 0)
 	rows, err := db.Query(`SELECT
 		a.OBJECT_TYPE,
 		a.PARENT_OBJECT_TYPE,
 		a.LABEL,
 		a.ICON,
 		a.PARENT_FILTER_FIELD,
 		b.PARENT_ID_FIELD
 		FROM LIST_CONFIG_NAVIGATION b
 		JOIN LIST_CONFIG_CHILD a ON b.PARENT_CHILD_ID = a.PARENT_CHILD_ID
 		WHERE b.LIST_OBJECT_TYPE = ` + fmt.Sprintf("'%s'", listObjType) +
 		` ORDER BY b.RB ASC`)
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	var node ListNavNode
 	for rows.Next() {
 		rows.Scan(&node.ObjectType, &node.ParentObjectType, &node.LabelField, &node.Icon,
 			&node.ParentFilterField, &node.ParentIDField)
 		list.Navigation = append(list.Navigation, node)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListActions returns list actions for the provided object type.
+// SetActions sets list's actions based for objType object type.
 func (list *ListConfig) SetActions(db *sql.DB, objType string) error {
 	rows, err := db.Query(`SELECT
 		ACTION_CREATE,
 		ACTION_UPDATE,
 		ACTION_DELETE,
 		ACTION_EXPORT,
 		ACTION_PRINT,
 		ACTION_GRAPH,
 		ACTION_LIVE_GRAPH,
 		ACTION_SAVE_FILE,
 		ACTION_SHOW_FILE
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	var create, update, delete, export, print, graph, liveGraph, saveFile, showFile uint32
 	if rows.Next() {
 		rows.Scan(&create, &update, &delete, &export, &print, &graph, &liveGraph, &saveFile, &showFile)
 		list.Actions.Create = create != 0
 		list.Actions.Update = update != 0
 		list.Actions.Delete = delete != 0
 		list.Actions.Export = export != 0
 		list.Actions.Print = print != 0
 		list.Actions.Graph = graph != 0
 		list.Actions.LiveGraph = liveGraph != 0
 		list.Actions.SaveFile = saveFile != 0
 		list.Actions.ShowFile = showFile != 0
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListFiters returns list filter slice for the provided object type.
+// SetFilters ...
 func (list *ListConfig) SetFilters(db *sql.DB, objType string) error {
 	list.Filters = make([]ListFilter, 0)
 	filtersFields, err := list.GetFilterFieldsAndPosition(db, objType)
 	if err != nil {
 		return err
 	}
 	for field, pos := range filtersFields {
-		filters, _ := list.GetFiltersByFilterField(db, field)
+		filters, _ := list.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" {
 				err := f.SetDropdownConfig(db, field)
 				if err != nil {
 					return err
 				}
 			}
 			list.Filters = append(list.Filters, f)
 		}
 	}
 	list.sortFilters()
 	return nil
 }
-// getFilterFieldsAndPosition returns a map of filter fields and their respective position in the menu.
+// GetFilterFieldsAndPosition returns a map of filter fields and their respective position in the menu.
 func (list *ListConfig) GetFilterFieldsAndPosition(db *sql.DB, objType string) (map[string]uint32, error) {
 	filtersField := make(map[string]uint32, 0)
 	rows, err := db.Query(`SELECT
 		FILTERS_FIELD,
 		RB
 		FROM LIST_CONFIG_FILTERS
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	for rows.Next() {
 		var field string
 		var rb uint32
 		rows.Scan(&field, &rb)
 		filtersField[field] = rb
 	}
 	if rows.Err() != nil {
 		return nil, rows.Err()
 	}
 	return filtersField, nil
 }
 type _filter struct {
 	DefaultValues string
 	Label         string
 	Type          string
 }
-// getFiltersByFilterField returns filter slice for the provided filter field.
+// getFiltersByFilterField ...
-func (list *ListConfig) GetFiltersByFilterField(db *sql.DB, filtersField string) ([]_filter, error) {
+func (list *ListConfig) getFiltersByFilterField(db *sql.DB, filtersField string) ([]_filter, error) {
 	resp := make([]_filter, 0)
 	rows, err := db.Query(`SELECT
 		FILTERS_TYPE,
 		FILTERS_LABEL,
 		DEFAULT_VALUES
 		FROM LIST_FILTERS_FIELD
 		WHERE FILTERS_FIELD = ` + fmt.Sprintf("'%s'", filtersField))
 	if err != nil {
 		return resp, err
 	}
 	defer rows.Close()
 	var f _filter
 	for rows.Next() {
 		rows.Scan(&f.Type, &f.Label, &f.DefaultValues)
 		resp = append(resp, f)
 	}
 	if rows.Err() != nil {
 		return resp, rows.Err()
 	}
 	return resp, nil
 }
-// getFilterDropdownConfig returns dropdown menu for the provided filter field.
+// SetDropdownConfig ...
 func (f *ListFilter) SetDropdownConfig(db *sql.DB, filtersField string) error {
 	var resp Dropdown
 	rows, err := db.Query(`SELECT
 		FILTERS_FIELD,
 		OBJECT_TYPE,
 		ID_FIELD,
 		LABEL_FIELD
 		FROM LIST_DROPDOWN_FILTER
 		WHERE FILTERS_FIELD = ` + fmt.Sprintf("'%s'", filtersField))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if rows.Next() {
 		rows.Scan(&resp.FiltersField, &resp.ObjectType, &resp.IDField, &resp.LabelField)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	f.DropdownConfig = resp
 	return nil
 }
 // sortFilters bubble sorts provided filters slice by position field.
 func (list *ListConfig) sortFilters() {
 	done := false
 	var temp ListFilter
 	for !done {
 		done = true
 		for i := 0; i < len(list.Filters)-1; i++ {
 			if list.Filters[i].Position > list.Filters[i+1].Position {
 				done = false
 				temp = list.Filters[i]
 				list.Filters[i] = list.Filters[i+1]
 				list.Filters[i+1] = temp
 			}
 		}
 	}
 }
-// getListGraph return list graph slice for the provided object type.
+// SetGraph ...
 func (list *ListConfig) SetGraph(db *sql.DB, objType string) error {
 	list.Graphs = make([]ListGraph, 0)
 	rows, err := db.Query(`SELECT
 		OBJECT_TYPE,
 		X_FIELD,
 		Y_FIELD,
 		GROUP_FIELD,
 		LABEL
 		FROM LIST_GRAPHS
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	var lg ListGraph
 	for rows.Next() {
 		rows.Scan(&lg.ObjectType, &lg.X, &lg.Y, &lg.GroupField, &lg.Label)
 		list.Graphs = append(list.Graphs, lg)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListOptions returns list options for the provided object type.
+// SetOptions ...
 func (list *ListConfig) SetOptions(db *sql.DB, objType string) error {
 	rows, err := db.Query(`SELECT
 		GLOBAL_FILTER,
 		LOCAL_FILTER,
 		REMOTE_FILTER,
 		PAGINATION,
 		PAGE_SIZE,
 		PIVOT,
 		DETAIL,
 		TOTAL
 		FROM LIST_CONFIG
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if rows.Next() {
 		var gfilter, lfilters, rfilters, pagination, pageSize, pivot, detail, total uint32
 		rows.Scan(&gfilter, &lfilters, &rfilters, &pagination, &pageSize, &pivot, &detail, &total)
 		list.Options.GlobalFilter = gfilter != 0
 		list.Options.LocalFilters = lfilters != 0
 		list.Options.RemoteFilters = rfilters != 0
 		list.Options.Pagination = pagination != 0
 		list.Options.PageSize = pageSize
 		list.Options.Pivot = pivot != 0
 		list.Options.Detail = detail != 0
 		list.Options.Total = total != 0
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListParent returns list parent node slice for the provided object type.
+// SetParent ...
 func (list *ListConfig) SetParent(db *sql.DB, objType string) error {
 	list.Parent = make([]ListParentNode, 0)
 	rows, err := db.Query(`SELECT
 		PARENT_OBJECT_TYPE,
 		PARENT_LABEL_FIELD,
 		PARENT_FILTER_FIELD
 		FROM LIST_CONFIG_CHILD
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	var pnode ListParentNode
 	for rows.Next() {
 		rows.Scan(&pnode.ObjectType, &pnode.LabelField, &pnode.FilterField)
 		list.Parent = append(list.Parent, pnode)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListPivot list pivot slice for the provided object type.
+// SetPivot ...
 func (list *ListConfig) SetPivot(db *sql.DB, objType string) error {
 	list.Pivots = make([]ListPivot, 0)
 	rows, err := db.Query(`SELECT
 		OBJECT_TYPE,
 		GROUP_FIELD,
 		DISTINCT_FIELD,
 		VALUE_FIELD
 		FROM LIST_PIVOTS
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	var p ListPivot
 	for rows.Next() {
 		rows.Scan(&p.ObjectType, &p.GroupField, &p.DistinctField, &p.Value)
 		list.Pivots = append(list.Pivots, p)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	return nil
 }
-// getListDetails returns list details for the provided object type.
+// SetDetails ...
 func (list *ListConfig) SetDetails(db *sql.DB, objType string) error {
 	var resp ListDetails
 	rows, err := db.Query(`SELECT
 		OBJECT_TYPE,
 		PARENT_OBJECT_TYPE,
 		PARENT_FILTER_FIELD,
 		SINGLE_DETAIL
 		FROM LIST_CONFIG_DETAIL
 		WHERE PARENT_OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if rows.Next() {
 		var singleDetail uint32
 		rows.Scan(&resp.ObjectType, &resp.ParentObjectType, &resp.ParentFilterField, &singleDetail)
 		resp.SingleDetail = singleDetail != 0
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	list.Details = resp
 	return nil
 }
-// getListLiveGraph returns live graph for the provided object type.
+// SetLiveGraph ...
 func (list *ListConfig) SetLiveGraph(db *sql.DB, objType string) error {
 	var resp ListLiveGraph
 	rows, err := db.Query(`SELECT
 		OBJECT_TYPE,
 		VALUE_FIELDS,
 		LABEL_FIELDS
 		FROM LIST_LIVE_GRAPH
 		WHERE OBJECT_TYPE = ` + fmt.Sprintf("'%s'", objType))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if rows.Next() {
 		rows.Scan(&resp.ObjectType, &resp.ValueFields, &resp.LabelFields)
 	}
 	if rows.Err() != nil {
 		return rows.Err()
 	}
 	list.LiveGraph = resp
 	return nil
 }

localization.go

Diff comments View file @7077823

 package webutility
 import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"path"
 	"strconv"
 	"strings"
 	"sync"
 )
+// Dictionary ...
 type Dictionary struct {
 	my            sync.Mutex
 	locales       map[string]map[string]string
 	supported     []string
 	defaultLocale string
 }
+// NewDictionary ...
 func NewDictionary() *Dictionary {
 	return &Dictionary{
 		locales: map[string]map[string]string{},
 	}
 }
+// AddTranslations ...
 func (d *Dictionary) AddTranslations(directory string) error {
 	files, err := ioutil.ReadDir(directory)
 	if err != nil {
 		return err
 	}
 	for _, fileInfo := range files {
 		fName := fileInfo.Name()
 		path := directory + "/" + fName
 		file, err := ioutil.ReadFile(path)
 		if err != nil {
 			return err
 		}
 		loc := stripFileExtension(fName)
 		var data interface{}
 		err = json.Unmarshal(file, &data)
 		if err != nil {
 			return err
 		}
 		l := map[string]string{}
 		for k, v := range data.(map[string]interface{}) {
 			l[k] = v.(string)
 		}
 		mu.Lock()
 		defer mu.Unlock()
 		d.locales[loc] = l
 		d.supported = append(d.supported, loc)
 	}
 	if d.defaultLocale == "" && len(d.supported) > 0 {
 		d.defaultLocale = d.supported[0]
 	}
 	return nil
 }
+// GetBestMatchLocale ...
 func (d *Dictionary) GetBestMatchLocale(req *http.Request) (best string) {
 	accepted := d.parseAcceptedLanguages(req.Header.Get("Accept-Language"))
-	for i, _ := range accepted {
+	for i := range accepted {
 		if accepted[i].Code == "*" {
 			return d.defaultLocale
 		}
-		for j, _ := range d.supported {
+		for j := range d.supported {
 			if accepted[i].Code == d.supported[j] {
 				return d.supported[j]
 			}
 		}
 	}
 	return d.defaultLocale
 }
+// Translate ...
 func (d *Dictionary) Translate(loc, key string) string {
 	return d.locales[loc][key]
 }
+// SetDefaultLocale ...
 func (d *Dictionary) SetDefaultLocale(loc string) error {
 	if !d.contains(loc) {
 		return fmt.Errorf("locale file not loaded: %s", loc)
 	}
 	d.defaultLocale = loc
 	return nil
 }
 func (d *Dictionary) contains(loc string) bool {
 	for _, v := range d.supported {
 		if v == loc {
 			return true
 		}
 	}
 	return false
 }
+// LangWeight ...
 type LangWeight struct {
 	Code   string
 	Weight float64
 }
 func (d *Dictionary) parseAcceptedLanguages(accepted string) (langs []LangWeight) {
 	if accepted == "" {
 		langs = append(langs, LangWeight{Code: d.defaultLocale, Weight: 1.0})
 		return langs
 	}
+	var code string
+	var weight float64
 	parts := strings.Split(accepted, ",")
-	for i, _ := range parts {
+	for i := range parts {
 		parts[i] = strings.Trim(parts[i], " ")
-		var code string = ""
-		var weight float64 = 0.0
 		cw := strings.Split(parts[i], ";")
 		paramCount := len(cw)
 		if paramCount == 1 {
 			// default weight of 1
 			code = cw[0]
 			weight = 1.0
 		} else if paramCount == 2 {
 			// parse weight
 			code = cw[0]
 			weight, _ = strconv.ParseFloat(cw[1][2:], 64)
 		}
 		langs = append(langs, LangWeight{Code: code, Weight: weight})
 	}
 	// TODO(marko): sort langs by weights?
 	return langs
 }
 func stripFileExtension(full string) (stripped string) {
 	extension := path.Ext(full)
 	stripped = strings.TrimSuffix(full, extension)

middleware.go

Diff comments View file @7077823

 package webutility
 import (
 	"net/http"
 	"time"
 	"git.to-net.rs/marko.tikvic/gologger"
 )
 var httpLogger *gologger.Logger
+// SetHeaders ...
 func SetHeaders(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		SetDefaultHeaders(w)
 		if req.Method == http.MethodOptions {
 			return
 		}
 		h(w, req)
 	}
 }
+// ParseForm ...
 func ParseForm(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		err := req.ParseForm()
 		if err != nil {
 			BadRequest(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }
+// ParseMultipartForm ...
 func ParseMultipartForm(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		err := req.ParseMultipartForm(32 << 20)
 		if err != nil {
 			BadRequest(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }
+// EnableLogging ...
 func EnableLogging(log string) (err error) {
 	httpLogger, err = gologger.New(log, gologger.MaxLogSize5MB)
 	return err
 }
+// Log ...
 func Log(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		t1 := time.Now()
 		claims, _ := GetTokenClaims(req)
 		in := httpLogger.LogHTTPRequest(req, claims.Username)
 		rec := NewStatusRecorder(w)
 		h(rec, req)
 		t2 := time.Now()
 		out := httpLogger.LogHTTPResponse(rec.Status(), t2.Sub(t1), rec.Size())
 		httpLogger.CombineHTTPLogs(in, out)
 	}
 }
+// Auth ...
 func Auth(roles string, h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		if _, err := AuthCheck(req, roles); err != nil {
 			Unauthorized(w, req, err.Error())
 			return
 		}
 		h(w, req)
 	}
 }

payload.go

Diff comments View file @7077823

 package webutility
 import (
 	"database/sql"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"strings"
 	"sync"
 	"time"
 	"git.to-net.rs/marko.tikvic/gologger"
 )
 var (
 	mu       = &sync.Mutex{}
 	metadata = make(map[string]Payload)
 	updateQue = make(map[string][]byte)
 	metadataDB    *sql.DB
 	activeProject string
 	inited bool
 	driver string
 	logger *gologger.Logger
 )
+// LangMap ...
 type LangMap map[string]map[string]string
+// Field ...
 type Field struct {
 	Parameter string `json:"param"`
 	Type      string `json:"type"`
 	Visible   bool   `json:"visible"`
 	Editable  bool   `json:"editable"`
 }
+// CorrelationField ...
 type CorrelationField struct {
 	Result   string   `json:"result"`
 	Elements []string `json:"elements"`
 	Type     string   `json:"type"`
 }
+// Translation ...
 type Translation struct {
 	Language     string            `json:"language"`
 	FieldsLabels map[string]string `json:"fieldsLabels"`
 }
-// output
+// PaginationLinks ...
 type PaginationLinks struct {
 	Base string `json:"base"`
 	Next string `json:"next"`
 	Prev string `json:"prev"`
 	Self string `json:"self"`
 }
-// input
+// PaginationParameters ...
 type PaginationParameters struct {
 	URL    string `json:"-"`
 	Offset int64  `json:"offset"`
 	Limit  int64  `json:"limit"`
 	SortBy string `json:"sortBy"`
 	Order  string `json:"order"`
 }
+// GetPaginationParameters ...
 // TODO(marko)
 func GetPaginationParameters(req *http.Request) (p PaginationParameters) {
 	return p
 }
 // TODO(marko)
 func (p *PaginationParameters) paginationLinks() (links PaginationLinks) {
 	return links
 }
+// Payload ...
 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"`
+	IDField      string             `json:"idField"`
 	// Pagination
 	Count int64           `json:"count"`
 	Total int64           `json:"total"`
 	Links PaginationLinks `json:"_links"`
 	// Data holds JSON payload. It can't be used for itteration.
 	Data interface{} `json:"data"`
 }
 func (p *Payload) addLang(code string, labels map[string]string) {
 	t := Translation{
 		Language:     code,
 		FieldsLabels: labels,
 	}
 	p.Lang = append(p.Lang, t)
 }
+// SetData ...
 func (p *Payload) SetData(data interface{}) {
 	p.Data = data
 }
+// SetPaginationInfo ...
 func (p *Payload) SetPaginationInfo(count, total int64, params PaginationParameters) {
 	p.Count = count
 	p.Total = total
 	p.Links = params.paginationLinks()
 }
 // NewPayload returs a payload sceleton for entity described with key.
 func NewPayload(r *http.Request, key string) Payload {
 	p := metadata[key]
 	p.Method = r.Method + " " + r.RequestURI
 	return p
 }
 // DecodeJSON decodes JSON data from r to v.
 // Returns an error if it fails.
 func DecodeJSON(r io.Reader, v interface{}) error {
 	return json.NewDecoder(r).Decode(v)
 }
 // InitPayloadsMetadata loads all payloads' information into 'metadata' variable.
 func InitPayloadsMetadata(drv string, db *sql.DB, project string) error {
 	var err error
 	if drv != "ora" && drv != "mysql" {
 		err = errors.New("driver not supported")
 		return err
 	}
 	driver = drv
 	metadataDB = db
 	activeProject = project
 	logger, err = gologger.New("metadata", gologger.MaxLogSize100KB)
 	if err != nil {
 		fmt.Printf("webutility: %s\n", err.Error())
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	err = initMetadata(project)
 	if err != nil {
 		return err
 	}
 	inited = true
 	return nil
 }
+// EnableHotloading ...
 func EnableHotloading(interval int) {
 	if interval > 0 {
 		go hotload(interval)
 	}
 }
+// GetMetadataForAllEntities ...
 func GetMetadataForAllEntities() map[string]Payload {
 	return metadata
 }
+// GetMetadataForEntity ...
 func GetMetadataForEntity(t string) (Payload, bool) {
 	p, ok := metadata[t]
 	return p, ok
 }
+// QueEntityModelUpdate ...
 func QueEntityModelUpdate(entityType string, v interface{}) {
 	updateQue[entityType], _ = json.Marshal(v)
 }
+// UpdateEntityModels ...
 func UpdateEntityModels(command string) (total, upd, add int, err error) {
 	if command != "force" && command != "missing" {
 		return total, 0, 0, errors.New("webutility: unknown command: " + command)
 	}
 	if !inited {
-		return 0, 0, 0, errors.New("webutility: metadata not initialized but update was tried.")
+		return 0, 0, 0, errors.New("webutility: metadata not initialized but update was tried")
 	}
 	total = len(updateQue)
 	toUpdate := make([]string, 0)
 	toAdd := make([]string, 0)
-	for k, _ := range updateQue {
+	for k := range updateQue {
 		if _, exists := metadata[k]; exists {
 			if command == "force" {
 				toUpdate = append(toUpdate, k)
 			}
 		} else {
 			toAdd = append(toAdd, k)
 		}
 	}
 	var uStmt *sql.Stmt
 	if driver == "ora" {
 		uStmt, err = metadataDB.Prepare("update entities set entity_model = :1 where entity_type = :2")
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 	} else if driver == "mysql" {
 		uStmt, err = metadataDB.Prepare("update entities set entity_model = ? where entity_type = ?")
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 	}
 	for _, k := range toUpdate {
 		_, err = uStmt.Exec(string(updateQue[k]), k)
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 		upd++
 	}
 	blankPayload, _ := json.Marshal(Payload{})
 	var iStmt *sql.Stmt
 	if driver == "ora" {
 		iStmt, err = metadataDB.Prepare("insert into entities(projekat, metadata, entity_type, entity_model) values(:1, :2, :3, :4)")
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 	} else if driver == "mysql" {
 		iStmt, err = metadataDB.Prepare("insert into entities(projekat, metadata, entity_type, entity_model) values(?, ?, ?, ?)")
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 	}
 	for _, k := range toAdd {
 		_, err = iStmt.Exec(activeProject, string(blankPayload), k, string(updateQue[k]))
 		if err != nil {
 			logger.Trace(err.Error())
 			return
 		}
 		metadata[k] = Payload{}
 		add++
 	}
 	return total, upd, add, nil
 }
 func initMetadata(project string) error {
 	rows, err := metadataDB.Query(`select
 		entity_type,
 		metadata
 		from entities
 		where projekat = ` + fmt.Sprintf("'%s'", project))
 	if err != nil {
 		return err
 	}
 	defer rows.Close()
 	if len(metadata) > 0 {
 		metadata = nil
 	}
 	metadata = make(map[string]Payload)
 	for rows.Next() {
 		var name, load string
 		rows.Scan(&name, &load)
 		p := Payload{}
 		err := json.Unmarshal([]byte(load), &p)
 		if err != nil {
 			logger.Log("webutility: couldn't init: '%s' metadata: %s:\n%s\n", name, err.Error(), load)
 		} else {
 			metadata[name] = p
 		}
 	}
 	return nil
 }
-// TODO(marko):
+// LoadMetadataFromFile expects file in format:
-//
-// Currently supports only one hardcoded language...
-//
-//
-//
-//
-//
-// Metadata file ecpected format:
 //
 // [ payload A identifier ]
 // key1 : value1
 // key2 : value2
 // ...
 // [ payload B identifier ]
 // key1 : value1
 // key2 : value2
 // ...
+//
+// TODO(marko): Currently supports only one hardcoded language...
 func LoadMetadataFromFile(path string) error {
 	lines, err := ReadFileLines(path)
 	if err != nil {
 		return err
 	}
 	metadata = make(map[string]Payload)
 	var name string
 	for i, l := range lines {
 		// skip empty lines
 		if l = trimSpaces(l); len(l) == 0 {
 			continue
 		}
 		if isWrappedWith(l, "[", "]") {
 			name = strings.Trim(l, "[]")
 			p := Payload{}
 			p.addLang("sr", make(map[string]string))
 			metadata[name] = p
 			continue
 		}
 		if name == "" {
-			return fmt.Errorf("webutility: LoadMetadataFromFile: error on line %d: [no header] [%s]\n", i+1, l)
+			return fmt.Errorf("webutility: LoadMetadataFromFile: error on line %d: [no header] [%s]", i+1, l)
 		}
 		parts := strings.Split(l, ":")
 		if len(parts) != 2 {
-			return fmt.Errorf("webutility: LoadMetadataFromFile: error on line %d: [invalid format] [%s]\n", i+1, l)
+			return fmt.Errorf("webutility: LoadMetadataFromFile: error on line %d: [invalid format] [%s]", i+1, l)
 		}
 		k := trimSpaces(parts[0])
 		v := trimSpaces(parts[1])
 		if v != "-" {
 			metadata[name].Lang[0].FieldsLabels[k] = v
 		}
 	}
 	return nil
 }
 func isWrappedWith(src, begin, end string) bool {
 	return strings.HasPrefix(src, begin) && strings.HasSuffix(src, end)
 }
 func trimSpaces(s string) string {
 	return strings.TrimSpace(s)
 }
+// ReadFileLines ...
 // TODO(marko): Move to separate package
 func ReadFileLines(path string) ([]string, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	var s strings.Builder
 	if _, err = io.Copy(&s, f); err != nil {
 		return nil, err
 	}
 	lines := strings.Split(s.String(), "\n")
 	return lines, nil
 }
 func hotload(n int) {
 	entityScan := make(map[string]int64)
 	firstCheck := true
 	for {
 		time.Sleep(time.Duration(n) * time.Second)
 		rows, err := metadataDB.Query(`select
 			ora_rowscn,
 			entity_type
 			from entities where projekat = ` + fmt.Sprintf("'%s'", activeProject))
 		if err != nil {
 			logger.Log("webutility: hotload failed: %v\n", err)
 			time.Sleep(time.Duration(n) * time.Second)
 			continue
 		}
 		var toRefresh []string
 		for rows.Next() {
 			var scanID int64
 			var entity string
 			rows.Scan(&scanID, &entity)
 			oldID, ok := entityScan[entity]
 			if !ok || oldID != scanID {
 				entityScan[entity] = scanID
 				toRefresh = append(toRefresh, entity)
 			}
 		}
 		rows.Close()
 		if rows.Err() != nil {
 			logger.Log("webutility: hotload rset error: %v\n", rows.Err())
 			time.Sleep(time.Duration(n) * time.Second)
 			continue
 		}
 		if len(toRefresh) > 0 && !firstCheck {
 			mu.Lock()
 			refreshMetadata(toRefresh)
 			mu.Unlock()
 		}
 		if firstCheck {
 			firstCheck = false
 		}
 	}
 }
 func refreshMetadata(entities []string) {
 	for _, e := range entities {
 		fmt.Printf("refreshing %s\n", e)
 		rows, err := metadataDB.Query(`select
 			metadata
 			from entities
 			where projekat = ` + fmt.Sprintf("'%s'", activeProject) +
 			` and entity_type = ` + fmt.Sprintf("'%s'", e))
 		if err != nil {
 			logger.Log("webutility: refresh: prep: %v\n", err)
 			rows.Close()
 			continue
 		}
 		for rows.Next() {
 			var load string
 			rows.Scan(&load)
 			p := Payload{}
 			err := json.Unmarshal([]byte(load), &p)
 			if err != nil {
 				logger.Log("webutility: couldn't refresh: '%s' metadata: %s\n%s\n", e, err.Error(), load)
 			} else {
 				metadata[e] = p
 			}
 		}
 		rows.Close()
 	}
 }
 /*
 func ModifyMetadataForEntity(entityType string, p *Payload) error {
 	md, err := json.Marshal(*p)
 	if err != nil {
 		return err
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	_, err = metadataDB.PrepAndExe(`update entities set
 		metadata = :1
 		where projekat = :2
 		and entity_type = :3`,
 		string(md),
 		activeProject,
 		entityType)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 func DeleteEntityModel(entityType string) error {
 	_, err := metadataDB.PrepAndExe("delete from entities where entity_type = :1", entityType)
 	if err == nil {

select_config.go

Diff comments View file @7077823

 package webutility
 import "database/sql"
+// SelectConfig ...
 type SelectConfig struct {
 	ListObjType string `json:"listObjectType"`
 	ObjType     string `json:"objectType"`
 	Type        string `json:"type"`
-	IdField     string `json:"idField"`
+	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 *sql.DB, otype string) ([]SelectConfig, error) {
 	resp := make([]SelectConfig, 0)
 	rows, err := db.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`)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	var sc SelectConfig
 	for rows.Next() {
-		rows.Scan(&sc.ListObjType, &sc.ObjType, &sc.IdField, &sc.LabelField, &sc.Type, &sc.ValueField)
+		rows.Scan(&sc.ListObjType, &sc.ObjType, &sc.IDField, &sc.LabelField, &sc.Type, &sc.ValueField)
 		resp = append(resp, sc)
 	}
 	if rows.Err() != nil {
 		return nil, rows.Err()
 	}
 	return resp, nil
 }

string_sanitisation.go

Diff comments View file @7077823

1	package webutility	1	package webutility
2		2
3	import "strings"	3	import "strings"
4		4
5	var patern string = "\"';&*<>=\\`:"	5	const patern = "\"';&*<>=\\`:"
6		6
7	// SQLSafeString removes characters from s found in patern and returns new modified string.	7	// SanitiseString removes characters from s found in patern and returns new modified string.
8	func SanitiseString(s string) (safe string) {	8	func SanitiseString(s string) (safe string) {
9	for _, c := range patern {	9	for _, c := range patern {
10	safe = strings.Replace(s, string(c), "", -1)	10	safe = strings.Replace(s, string(c), "", -1)
11	}	11	}
12	return safe	12	return safe
13	}	13	}
14		14