Marko Tikvić / webutility

Browse Code »

Commit 46b2215ebd14695c0d2bf23dc7a2157ffa2de7c0

Authored by Marko Tikvić 2019-07-04 11:55:31 +0200

1 parent 6b7121bdf6

Exists in master

lintfix

Showing 4 changed files with 20 additions and 0 deletions Show diff stats

default_values.go

Diff comments View file @46b2215

 package webutility
 // IntOrDefault ...
 func IntOrDefault(v *int) int {
 	if v != nil {
 		return *v
 	}
 	return 0
 }
 // Int32OrDefault ...
 func Int32OrDefault(v *int32) int32 {
 	if v != nil {
 		return *v
 	}
 	return 0
 }
 // Int64OrDefault ...
 func Int64OrDefault(v *int64) int64 {
 	if v != nil {
 		return *v
 	}
 	return 0
 }
 // Uint32OrDefault ...
 func Uint32OrDefault(v *uint32) uint32 {
 	if v != nil {
 		return *v
 	}
 	return 0
 }
 // Uint64OrDefault ...
 func Uint64OrDefault(v *uint64) uint64 {
 	if v != nil {
 		return *v
 	}
 	return 0
 }
 // StringOrDefault ...
 func StringOrDefault(v *string) string {
 	if v != nil {
 		return *v
 	}
 	return ""
 }
 // Float32OrDefault ...
 func Float32OrDefault(v *float32) float32 {
 	if v != nil {
 		return *v
 	}
 	return 0.0
 }
 // Float64OrDefault ...
 func Float64OrDefault(v *float64) float64 {
 	if v != nil {
 		return *v
 	}
 	return 0.0
 }
+// NilSafeInt32OrDefault ...
 func NilSafeInt32OrDefault(val *interface{}) int32 {
 	if *val != nil {
 		return (*val).(int32)
 	}
 	return 0
 }
+// NilSafeInt64OrDefault ...
 func NilSafeInt64OrDefault(val *interface{}) int64 {
 	if *val != nil {
 		return (*val).(int64)
 	}
 	return 0
 }
+// NilSafeUint32OrDefault ...
 func NilSafeUint32OrDefault(val *interface{}) uint32 {
 	if *val != nil {
 		return (*val).(uint32)
 	}
 	return 0
 }
+// NilSafeUint64OrDefault ...
 func NilSafeUint64OrDefault(val *interface{}) uint64 {
 	if *val != nil {
 		return (*val).(uint64)
 	}
 	return 0
 }
+// NilSafeFloat32OrDefault ...
 func NilSafeFloat32OrDefault(val *interface{}) float32 {
 	if *val != nil {
 		return (*val).(float32)
 	}
 	return 0.0
 }
+// NilSafeFloat64OrDefault ...
 func NilSafeFloat64OrDefault(val *interface{}) float64 {
 	if *val != nil {
 		return (*val).(float64)
 	}
 	return 0.0
 }
+// NilSafeStringOrDefault ...
 func NilSafeStringOrDefault(val *interface{}) string {
 	if *val != nil {
 		return (*val).(string)
 	}
 	return ""
 }

file_util.go

Diff comments View file @46b2215

 package webutility
 import (
 	"bytes"
 	"io"
 	"io/ioutil"
 	"os"
 	"strings"
 )
+// ReadFileContent ...
 func ReadFileContent(path string) ([]byte, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	buf := &bytes.Buffer{}
 	if _, err = io.Copy(buf, f); err != nil {
 		return nil, err
 	}
 	return buf.Bytes(), nil
 }
 // ReadFileLines ...
 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")
 	for i := range lines {
 		lines[i] = strings.TrimRight(lines[i], "\r\n")
 	}
 	return lines, nil
 }
 // LinesToFile ...
 func LinesToFile(path string, lines []string) error {
 	content := ""
 	for _, l := range lines {
 		content += l + "\n"
 	}
 	return ioutil.WriteFile(path, []byte(content), 0644) // drw-r--r--
 }
 // InsertLine ...
 func InsertLine(lines *[]string, pos int64, l string) {
 	tail := append([]string{l}, (*lines)[pos:]...)
 	*lines = append((*lines)[:pos], tail...)
 }

http.go

Diff comments View file @46b2215

 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,
 	}
 }
 // WriteHeader is a wrapper http.ResponseWriter interface
 func (r *StatusRecorder) WriteHeader(code int) {
 	r.status = code
 	r.writer.WriteHeader(code)
 }
 // 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)
 }
 // 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()))
 }
+// SetContentType ...
 func SetContentType(w http.ResponseWriter, ctype string) {
 	w.Header().Set("Content-Type", ctype)
 }
+// SetResponseStatus ...
 func SetResponseStatus(w http.ResponseWriter, status int) {
 	w.WriteHeader(status)
 }
+// WriteResponse ...
 func WriteResponse(w http.ResponseWriter, content []byte) {
 	w.Write(content)
 }
 // 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")
 	SetContentType(w, "application/json; charset=utf-8")
 }
 // GetLocale ...
 func GetLocale(req *http.Request, dflt string) string {
 	loc := req.FormValue("locale")
 	if loc == "" {
 		return dflt
 	}
 	return loc
 }
 // Success ...
 func Success(w http.ResponseWriter, payload interface{}, code int) {
 	w.WriteHeader(code)
 	if payload != nil {
 		json.NewEncoder(w).Encode(payload)
 	}
 }
 // OK ...
 func OK(w http.ResponseWriter, payload interface{}) {
 	Success(w, payload, http.StatusOK)
 }
 // Created ...
 func Created(w http.ResponseWriter, payload interface{}) {
 	Success(w, payload, http.StatusCreated)
 }
 type weberror struct {
 	Request string `json:"request"`
 	Error   string `json:"error"`
 }
 // 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)
 }
 // BadRequest ...
 func BadRequest(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusBadRequest, err)
 }
 // Unauthorized ...
 func Unauthorized(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusUnauthorized, err)
 }
 // Forbidden ...
 func Forbidden(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusForbidden, err)
 }
 // NotFound ...
 func NotFound(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusNotFound, err)
 }
 // Conflict ...
 func Conflict(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusConflict, err)
 }
 // InternalServerError ...
 func InternalServerError(w http.ResponseWriter, r *http.Request, err string) {
 	Error(w, r, http.StatusInternalServerError, err)
 }

string_util.go

Diff comments View file @46b2215

 package webutility
 import (
 	"fmt"
 	"strconv"
 	"strings"
 )
 const sanitisationPatern = "\"';&*<>=\\`:"
 // SanitiseString removes characters from s found in patern and returns new modified string.
 func SanitiseString(s string) string {
 	return ReplaceAny(s, sanitisationPatern, "")
 }
 // IsWrappedWith ...
 func IsWrappedWith(src, begin, end string) bool {
 	return strings.HasPrefix(src, begin) && strings.HasSuffix(src, end)
 }
 // ParseInt64Arr ...
 func ParseInt64Arr(s, sep string) (arr []int64) {
 	s = strings.TrimSpace(s)
 	if s != "" {
 		parts := strings.Split(s, sep)
 		arr = make([]int64, len(parts))
 		for i, p := range parts {
 			num := StringToInt64(p)
 			arr[i] = num
 		}
 	}
 	return arr
 }
 // Int64SliceToString ...
 func Int64SliceToString(arr []int64) (s string) {
 	if len(arr) == 0 {
 		return ""
 	}
 	s += fmt.Sprintf("%d", arr[0])
 	for i := 1; i < len(arr); i++ {
 		s += fmt.Sprintf(",%d", arr[i])
 	}
 	return s
 }
 // CombineStrings ...
 func CombineStrings(s1, s2, s3 string) string {
 	s1 = strings.TrimSpace(s1)
 	s2 = strings.TrimSpace(s2)
 	if s1 != "" && s2 != "" {
 		s1 += s3 + s2
 	} else {
 		s1 += s2
 	}
 	return s1
 }
 // ReplaceAny replaces any of the characters from patern found in s with r and returns a new resulting string.
 func ReplaceAny(s, patern, r string) (n string) {
 	n = s
 	for _, c := range patern {
 		n = strings.Replace(n, string(c), r, -1)
 	}
 	return n
 }
+// StringToBool ...
 func StringToBool(s string) bool {
 	res, _ := strconv.ParseBool(s)
 	return res
 }
+// BoolToString ...
 func BoolToString(b bool) string {
 	return fmt.Sprintf("%b", b)
 }
+// StringSliceContains ...
 func StringSliceContains(slice []string, s string) bool {
 	for i := range slice {
 		if slice[i] == s {
 			return true
 		}
 	}
 	return false
 }
+// StringAt ...
 func StringAt(s string, index int) string {
 	if len(s)-1 < index || index < 0 {
 		return ""
 	}
 	return string(s[index])
 }
+// SplitStringAtWholeWords ...
 func SplitStringAtWholeWords(s string, maxLen int) (res []string) {
 	parts := strings.Split(s, " ")
 	res = append(res, parts[0])
 	i := 0
 	for j := 1; j < len(parts); j++ {
 		p := strings.TrimSpace(parts[j])
 		if len(p) > maxLen {
 			// TODO(marko): check if maxLen is >= 3
 			p = p[0 : maxLen-3]
 			p += "..."
 		}
 		if len(res[i])+len(p)+1 <= maxLen {
 			res[i] += " " + p
 		} else {
 			res = append(res, p)
 			i++
 		}
 	}
 	return res
 }