Marko Tikvić / webutility

Browse Code »

Commit 90fd36e9b6905db92e6323daa89e0474e8d060c7

Authored by Marko Tikvić 2016-09-21 14:36:34 +0200

1 parent 514fa9dd68

Exists in master and in 1 other branch

resolved some dependency issues

Showing 5 changed files with 170 additions and 49 deletions Show diff stats

auth_utility.go

Diff comments View file @90fd36e

File was created	1	package restutility
	2
	3	import (
	4	// "fmt"
	5	"errors"
	6	// "os"
	7	"time"
	8	"crypto/sha256"
	9	"crypto/rand"
	10	"encoding/hex"
	11	"strings"
	12	"github.com/dgrijalva/jwt-go"
	13	// "github.com/SermoDigital/jose/jwt"
	14	)
	15
	16	const OneDay = time.Hour*24
	17	const OneWeek = OneDay*7
	18	const saltSize = 32
	19	const appName = "korisnicki-centar"
	20	const secret = "korisnicki-centar-api"
	21
	22	type Token struct {
	23	TokenString string `json:"token"`
	24	}
	25
	26	type TokenClaims struct {
	27	Username string `json:"username"`
	28	Role string `json:"role"`
	29	jwt.StandardClaims
	30	}
	31
	32	type CredentialsStruct struct {
	33	Username string `json:"username"`
	34	Password string `json:"password"`
	35	}
	36
	37	func generateSalt() (string, error) {
	38	salt := ""
	39
	40	rawsalt := make([]byte, saltSize)
	41	_, err := rand.Read(rawsalt)
	42	if err != nil {
	43	return "", err
	44	}
	45	salt = hex.EncodeToString(rawsalt)
	46	return salt, nil
	47	}
	48
	49	func hashMessage(message string, presalt string) (string, string, error) {
	50	hash, salt := "", ""
	51	var err error
	52
	53	// chech if message is presalted
	54	if presalt == "" {
	55	salt, err = generateSalt()
	56	if err != nil {
	57	return "", "", err
	58	}
	59	} else {
	60	salt = presalt
	61	}
	62
	63	// convert strings to raw byte slices
	64	rawmessage := []byte(message)
	65	rawsalt, err := hex.DecodeString(salt)
	66	if err != nil {
	67	return "", "", err
	68	}
	69	rawdata := make([]byte, len(rawmessage) + len(rawsalt))
	70	rawdata = append(rawdata, rawmessage...)
	71	rawdata = append(rawdata, rawsalt...)
	72
	73	// hash message + salt
	74	hasher := sha256.New()
	75	hasher.Write(rawdata)
	76	rawhash := hasher.Sum(nil)
	77	hash = hex.EncodeToString(rawhash)
	78	return hash, salt, nil
	79	}
	80
	81	func issueAPIToken(username, role string) (Token, error) {
	82	var apiToken Token
	83	var err error
	84
	85	if err != nil {
	86	return Token{}, err
	87	}
	88
	89	claims := TokenClaims{
	90	username,
	91	role,
	92	jwt.StandardClaims{
	93	ExpiresAt: (time.Now().Add(OneWeek)).Unix(),
	94	Issuer: appName,
	95	},
	96	}
	97
	98	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	99	apiToken.TokenString, err = jwtToken.SignedString([]byte(secret))
	100	if err != nil {
	101	return Token{}, err
	102	}
	103	return apiToken, nil
	104	}
	105
	106	func refreshAPIToken(tokenString string) (Token, error) {
	107	var newToken Token
	108	tokenString = strings.TrimPrefix(tokenString, "Bearer ")
	109	token, err := parseTokenFunc(tokenString)
	110	if err != nil {
	111	return Token{}, err
	112	}
	113
	114	// type assertion
	115	claims, ok := token.Claims.(*TokenClaims)
	116	if !ok \|\| !token.Valid {
	117	return Token{}, errors.New("token is not valid")
	118	}
	119
	120	claims.ExpiresAt = (time.Now().Add(OneWeek)).Unix()
	121	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	122
	123	newToken.TokenString, err = jwtToken.SignedString([]byte(secret))
	124	if err != nil {
	125	return Token{}, err
	126	}
	127
	128	return newToken, nil
	129	}
	130
	131	func parseAPIToken(tokenString string) (*TokenClaims, error) {
	132	if ok := strings.HasPrefix(tokenString, "Bearer"); ok {
	133	tokenString = strings.TrimPrefix(tokenString, "Bearer ")
	134	} else {
	135	return &TokenClaims{}, errors.New("Authorization header is incomplete")
	136	}
	137
	138	token, err := parseTokenFunc(tokenString)
	139	if err != nil {
	140	return &TokenClaims{}, err
	141	}
	142
	143	// type assertion
	144	claims, ok := token.Claims.(*TokenClaims)
	145	if !ok \|\| !token.Valid {
	146	return &TokenClaims{}, errors.New("token is not valid")
	147	}
	148	return claims, nil
	149	}
	150
	151	func parseTokenFunc(tokenString string) (*jwt.Token, error) {
	152	token, err := jwt.ParseWithClaims(tokenString,
	153	&TokenClaims{},
	154	func(token *jwt.Token) (interface{}, error) {
	155	return []byte(secret), nil
	156	},
	157	)
	158	return token, err
	159	}
	160
	161	func authMinRegReq(uname, pword string) (bool, error) {
	162	return true, nil
	163	}
	164
	165

format_utility.go

Diff comments View file @90fd36e

1	package main	1	package restutility
2		2
3	import (	3	import (
4	"strings"	4	"strings"
5	"time"	5	"time"
6	"strconv"	6	"strconv"
7	)	7	)
8		8
9	////	9	////
10	//// TIME FORMAT UTILITY	10	//// TIME FORMAT UTILITY
11	////	11	////
12		12
13	func unixToDate(input int64) time.Time {	13	func unixToDate(input int64) time.Time {
14	return time.Unix(input, 0)	14	return time.Unix(input, 0)
15	}	15	}
16		16
17	func dateToUnix(input interface{}) int64 {	17	func dateToUnix(input interface{}) int64 {
18	if input != nil {	18	if input != nil {
19	t := input.(time.Time)	19	t := input.(time.Time)
20	return t.Unix()	20	return t.Unix()
21		21
22	}	22	}
23	return 0	23	return 0
24	}	24	}
25		25
26	func aersDate(unixString string) (string, error) {	26	func aersDate(unixString string) (string, error) {
27	unixTime, err := strconv.ParseInt(unixString, 10, 64)	27	unixTime, err := strconv.ParseInt(unixString, 10, 64)
28	if err != nil {	28	if err != nil {
29	return "", err	29	return "", err
30	}	30	}
31		31
32	date := unixToDate(unixTime).String()	32	date := unixToDate(unixTime).String()
33	tokens := strings.Split(date, "-")	33	tokens := strings.Split(date, "-")
34	dateString := tokens[0] + tokens[1] + strings.Split(tokens[2], " ")[0]	34	dateString := tokens[0] + tokens[1] + strings.Split(tokens[2], " ")[0]
35		35
36	return dateString, nil	36	return dateString, nil
37	}	37	}
38		38
39	////	39	////
40	//// STRING UTILITY	40	//// STRING UTILITY
41	////	41	////
42		42
43	// surrondWithSingleQuotes is used when url param is of type string	43	// surrondWithSingleQuotes is used when url param is of type string
44	func putQuotes(input string) string {	44	func putQuotes(input string) string {
45	if input != "" {	45	if input != "" {
46	return " = '" + input + "'"	46	return " = '" + input + "'"
47	}	47	}
48	return ""	48	return ""
49	}	49	}
50		50
51	func putLikeQuotes(input string) string {	51	func putLikeQuotes(input string) string {
52	if input != "" {	52	if input != "" {
53	return " LIKE UPPER('%" + input + "%')"	53	return " LIKE UPPER('%" + input + "%')"
54	}	54	}
55	return ""	55	return ""
56	}	56	}
57		57
58		58

http_utility.go

Diff comments View file @90fd36e

 package restutility
 import (
 	"net/http"
 	"encoding/json"
 )
+const APIVersion = "/api/v1"
 ////
 //// ERROR UTILITY
 ////
 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."
 type HttpError struct {
 	Error   []HttpErrorDesc `json:"error"`
 	Request string          `json:"request"`
 }
 type HttpErrorDesc struct {
 	Lang string `json:"lang"`
 	Desc string `json:"description"`
 }
 func respondWithHttpError(w http.ResponseWriter,
 	req *http.Request,
 	code int,
 	httpErr []HttpErrorDesc) {
 	err := HttpError{
 		Error: httpErr,
 		Request: req.Method + " " + req.URL.Path,
 	}
 	w.WriteHeader(code)
 	json.NewEncoder(w).Encode(err)
 }
 func respondWithHttpError400(w http.ResponseWriter, req *http.Request) {
 	respondWithHttpError(w, req, http.StatusBadRequest,
 		[]HttpErrorDesc{
 			{
 				Lang: "en",
 				Desc: templateHttpErr400_EN,
 			},
 			{
 				Lang: "rs",
 				Desc: templateHttpErr400_RS,
 			},
 		})
 }
 func respondWithHttpError500(w http.ResponseWriter, req *http.Request) {
 	respondWithHttpError(w, req, http.StatusInternalServerError,
 		[]HttpErrorDesc{
 			{
 				Lang: "en",
 				Desc: templateHttpErr500_EN,
 			},
 			{
 				Lang: "rs",
 				Desc: templateHttpErr500_RS,
 			},
 		})
 }
 func deliverPayload(w http.ResponseWriter, payload JSONPayload) {
 	json.NewEncoder(w).Encode(payload)
 	payload.Data = nil
 }
 ////
 //// HANDLER FUNC WRAPPER
 ////
 // wrapHandlerFunc is as wrapper function for route handlers.
 // Sets common headers and checks for token validity.
 func commonHttpWrap(fn http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 //		@TODO: check Content-type header (must be application/json)
 //		ctype := w.Header.Get("Content-Type")
 //		if req.Method != "GET" && ctype != "application/json" {
 //			replyWithHttpError(w, req, http.StatusBadRequest,
 //				"Not a supported content type: " + ctype)
 //		}
 		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 req.URL.Path != APIVersion + "/token/new" {
 			token := req.Header.Get("Authorization")
 			if _, err := parseAPIToken(token); err != nil {
 				respondWithHttpError(w, req, http.StatusUnauthorized,
 					[]HttpErrorDesc{
 						{
 							Lang: "en",
 							Desc: "Unauthorized request.",
 						},
 						{
 							Lang: "rs",
 							Desc: "Neautorizovani zahtev.",
 						},
 					})
 				return
 			}
 		}
 		err := req.ParseForm()
 		if err != nil {
 			respondWithHttpError(w, req, http.StatusBadRequest,
 				[]HttpErrorDesc{
 					{
 						Lang: "en",
 						Desc: templateHttpErr400_EN,
 					},
 					{
 						Lang: "rs",
 						Desc: templateHttpErr400_RS,
 					},
 				})
 			return
 		}
 		fn(w, req)
 	}
 }
 ////
 //// NOT FOUND HANDLER
 ////
 func notFoundHandler(w http.ResponseWriter, req *http.Request) {
 	respondWithHttpError(w, req, http.StatusNotFound,
 		[]HttpErrorDesc{
 			{
 				Lang: "en",
 				Desc: "Not found.",
 			},
 			{
 				Lang: "rs",
 				Desc: "Traženi resurs ne postoji.",
 			},
 		})
 }

json_utility.go

Diff comments View file @90fd36e

 package restutility
 import (
 	"net/http"
 	"strings"
 )
-const APIVersion "/api/v1"
 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 JSONParams struct {
 	Lang    LangMap
 	Fields  []Field
 	IdField string
 	Correlations []CorrelationField `json:"correlation_fields"`
 }
 type JSONPayload struct {
 	Method	     string             `json:"method"`
 	Params	     map[string]string  `json:"params"`
 	Lang	     LangMap            `json:"lang"`
 	Fields	     []Field            `json:"fields"`
 	Correlations []CorrelationField `json:"correlation_fields"`
 	IdField      string             `json:"idField"`
 	// Data can only hold slices of any type. It can't be used for itteration
 	Data	     interface{}        `json:"data"`
 }
 func NewJSONParams(lang LangMap,
 	fields []Field,
 	id string,
 	correlations []CorrelationField) JSONParams {
 	var jp JSONParams
 	jp.Lang = lang
 	jp.Fields = fields
 	jp.IdField = id
 	jp.Correlations = correlations
 	return jp
 }
 func NewJSONPayload(r *http.Request, params JSONParams) JSONPayload {
 	var obj JSONPayload
 	obj.Method = strings.ToLower(r.Method + " " + r.URL.Path)
 	obj.Params = make(map[string]string, 0)
 	obj.Lang = make(map[string]map[string]string, 0)
 	obj.Fields = make([]Field, 0)
 	obj.IdField = params.IdField
 	obj.Correlations = params.Correlations
 	for k, m := range params.Lang {
 		obj.Lang[k] = m
 	}
 	for _, f := range params.Fields {
 		obj.Fields = append(obj.Fields, f)
 	}
 	return obj
 }

tables_utility.go

Diff comments View file @90fd36e

 package restutility
 import (
 	"encoding/json"
-	"io"
-	"io/ioutil"
 	"errors"
-	"fmt"
-	"gopkg.in/rana/ora.v3"
 )
 type TableConfig struct {
 	Tables []Table
 }
 type Table struct {
 	TableType    string             `json:"tableType"`
 	Translations []TableTranslation `json:"translations"`
 	TableFields  []Field            `json:"tableFields"`
 	Correlations []CorrelationField `json:"correlation_fields"`
 	IdField      string             `json:"idField"`
 }
 type CorrelationField struct {
 	Result   string   `json:"result"`
 	Elements []string `json:"elements"`
 	Type     string   `json:"type"`
 }
 type TableTranslation struct {
 	Language     string            `json:"language"`
 	FieldsLabels map[string]string `json:"fieldsLabels"`
 }
 func (tl TableConfig) LoadTranslations(tableType string) LangMap {
 	translations := make(LangMap, 0)
 	for _, table := range tl.Tables {
 		if tableType == table.TableType {
 			for _, t := range table.Translations {
 				translations[t.Language] = t.FieldsLabels
 			}
 		}
 	}
 	return translations
 }
 func (tl TableConfig) LoadFields(tableType string) []Field {
 	fields := make([]Field, 0)
 	for _, table := range tl.Tables {
 		if tableType == table.TableType {
 			for _, f := range table.TableFields {
 				fields = append(fields, f)
 			}
 		}
 	}
 	return fields
 }
 func (tl TableConfig) LoadIdField(tableType string) string {
 	for _, table := range tl.Tables {
 		if tableType == table.TableType {
 			return table.IdField
 		}
 	}
 	return ""
 }
 func (tl TableConfig) LoadCorrelations(tableType string) []CorrelationField {
 	resp := make([]CorrelationField, 0)
 	for _, table := range tl.Tables {
 		if tableType == table.TableType {
 			for _, f := range table.Correlations {
 				resp = append(resp, f)
 			}
 		}
 	}
 	return resp
 }
 var _tables TableConfig
 var _prevProject string
-func getTablesConfigJSON(project string) error {
+func loadTablesConfig(jsonbuf []byte) error {
-	_prevProject = project
+	json.Unmarshal(jsonbuf, &_tables.Tables)
-	stmt, err := Oracle.Ses.Prep(`SELECT
-		JSON_CLOB
-		FROM TABLES_CONFIG
-		WHERE PROJEKAT` + project, ora.S)
-	defer stmt.Close()
-	if err != nil {
+	if len(_tables.Tables) == 0 {
-		return err
-	}
-	rset, err := stmt.Qry()
-	if err != nil {
-		return err
-	}
-	if rset.Next() {
-		lob := rset.Row[0].(io.Reader)
-		bytes, err := ioutil.ReadAll(lob)
-		if err != nil {
-			fmt.Printf("mega error: %v\n", err)
-		}
-		json.Unmarshal(bytes, &_tables.Tables)
-	}
-	return nil
-}
-func loadTablesConfig(project string) error {
-	err := getTablesConfigJSON(putQuotes(project))
-	//file, err := ioutil.ReadFile("./config/tables-config.json")
-	if err != nil {
-		fmt.Printf("%v\n", err);
-		return errors.New("unable to load tables config")
-	}
-	//json.Unmarshal(file, &_TABLES_CONFIG.Tables)
-	if len(_TABLES_CONFIG.Tables) == 0 {
 		return errors.New("tables config is corrupt")
 	}
 	return nil
 }
 func loadTable(table string) JSONParams {
 	return NewJSONParams(_tables.LoadTranslations(table),
 			_tables.LoadFields(table),
 			_tables.LoadIdField(table),
 			_tables.LoadCorrelations(table))
 }
-func refreshTables() error {
-	return getTablesConfigJSON(_prevProject)
-}