Marko Tikvić / webutility

Browse Code »

Commit 4a51e54d7e426f07551271cb1a96f69a991992c8

Authored by Marko Tikvić 2016-09-23 16:03:21 +0200

1 parent ecec68b180

Exists in master and in 1 other branch

simplified

Showing 2 changed files with 49 additions and 30 deletions Show diff stats

http_utility.go

Diff comments View file @4a51e54

 package restutility
 import (
 	"net/http"
 	"encoding/json"
 )
-var _apiVersion = "/api/v1"
+var _apiVersion   = ""
+var _authEndPoint = ""
 func SetApiVersion(ver string) string {
 	_apiVersion = ver
 	return _apiVersion
 }
+func SetAuthEndpoint(ep string) {
+	_authEndPoint = ep
+}
 ////
 //// 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},
 	})
 }
 ////
 //// HANDLER FUNC WRAPPER
 ////
 //TODO: Add parameters to enable/disable token and roles authorization checks
 // Sets common headers and checks for token validity.
-func ProcessHeaders(fn http.HandlerFunc) http.HandlerFunc {
+func ProcessHeaders(fn http.HandlerFunc, shouldAuth bool) 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" {
+		if shouldAuth {
-			token := req.Header.Get("Authorization")
+			if req.URL.Path != _apiVersion + _authEndPoint {
-			if _, err := ParseAPIToken(token); err != nil {
+				token := req.Header.Get("Authorization")
-				RespondWithHttpError(w, req, http.StatusUnauthorized,
+				if _, err := ParseAPIToken(token); err != nil {
-					[]HttpErrorDesc{
+					RespondWithHttpError(w, req, http.StatusUnauthorized,
-						{Lang: "en", Desc: "Unauthorized request."},
+						[]HttpErrorDesc{
-						{Lang: "rs", Desc: "Neautorizovani zahtev."},
+							{Lang: "en", Desc: "Unauthorized request."},
-					})
+							{Lang: "rs", Desc: "Neautorizovani zahtev."},
-				return
+						})
+					return
+				}
 			}
 		}
 		err := req.ParseForm()
 		if err != nil {
 			RespondWithHttpError(w, req, http.StatusBadRequest,
 				[]HttpErrorDesc{
 					{Lang: "en", Desc: templateHttpErr400_EN},
 					{Lang: "rs", Desc: templateHttpErr400_RS},
 				})
 			return
 		}
+		// execute HandlerFunc
 		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 @4a51e54

 package restutility
 import (
 	"net/http"
-	"strings"
 	"encoding/json"
 	"errors"
 	"gopkg.in/rana/ora.v3"
 	"io"
 	"io/ioutil"
-	"fmt"
 )
-var allPayloads []Payload
+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"`
 }
-type Payload struct {
+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"`
+}
 func NewPayload(r *http.Request, table string) Payload {
 	var pload Payload
-	pload.Method = strings.ToLower(r.Method + " " + r.URL.Path)
+	pload.Method = r.Method + " " + r.URL.Path
 	pload.Params = make(map[string]string, 0)
-	pload.Lang = loadTranslations(allPayloads, table)
+	pload.Lang = loadTranslations(table)
-	pload.Fields = loadFields(allPayloads, table)
+	pload.Fields = loadFields(table)
-	pload.IdField = loadIdField(allPayloads, table)
+	pload.IdField = loadIdField(table)
-	pload.Correlations = loadCorrelations(allPayloads, table)
+	pload.Correlations = loadCorrelations(table)
 	return pload
 }
 func DeliverPayload(w http.ResponseWriter, payload Payload) {
 	json.NewEncoder(w).Encode(payload)
 	payload.Data = nil
 }
-func loadTranslations(payloads []Payload, id string) []Translation {
+func loadTranslations(id string) []Translation {
 	translations := make([]Translation, 0)
-	for _, pload := range payloads {
+	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
 }
-func loadFields(payloads []Payload, id string) []Field {
+func loadFields(id string) []Field {
 	fields := make([]Field, 0)
-	for _, pload := range payloads {
+	for _, pload := range allPayloads {
 		if pload.Type == id{
 			for _, f := range pload.Fields {
 				fields = append(fields, f)
 			}
 		}
 	}
 	return fields
 }
-func loadIdField(payloads []Payload, id string) string {
+func loadIdField(id string) string {
-	for _, pload := range payloads {
+	for _, pload := range allPayloads {
 		if pload.Type == id {
 			return pload.IdField
 		}
 	}
 	return ""
 }
-func loadCorrelations(payloads []Payload, id string) []CorrelationField {
+func loadCorrelations(id string) []CorrelationField {
 	resp := make([]CorrelationField, 0)
-	for _, pload := range payloads {
+	for _, pload := range allPayloads {
 		if pload.Type == id {
 			for _, f := range pload.Correlations {
 				resp = append(resp, f)
 			}
 		}
 	}
 	return resp
 }
 func InitTables(db *ora.Ses, project string) error {
 	jsonbuf, _ := fetchTablesConfig(db, EqualQuotes(project))
 	json.Unmarshal(jsonbuf, &allPayloads)
 	if len(allPayloads) == 0 {
 		return errors.New("tables config is corrupt")
 	}
-	fmt.Printf("broj ucitanih tabela: %d\n", len(allPayloads))
 	return nil
 }
 func fetchTablesConfig(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 {
-			fmt.Printf("mega error: %v\n", err)
+			// TODO: Find a fix for this.
+			// Ignore, it's some weird streaming read/write LOB error.
+			//return nil, err
 		}
 	}
 	return bytes, nil