Marko Tikvić / webutility

Browse Code »

Commit 9933169c81dffadf646a7825aa721e8e297f772f

Authored by Marko Tikvić 2018-04-03 13:45:07 +0200

1 parent ff2508880c

Exists in master and in 1 other branch

localization support

Showing 3 changed files with 121 additions and 23 deletions Show diff stats

http_utility.go

Diff comments View file @9933169

1	package webutility	1	package webutility
2		2
3	import (	3	import (
4	"encoding/json"	4	"encoding/json"
5	"net/http"	5	"net/http"
6	)	6	)
7		7
		8	type webError struct {
		9	Request string `json:"request"`
		10	Error string `json:"error"`
		11	}
		12
		13	// NotFoundHandler writes HTTP error 404 to w.
		14	func NotFoundHandler(w http.ResponseWriter, req *http.Request) {
		15	SetDefaultHeaders(w)
		16	if req.Method == "OPTIONS" {
		17	return
		18	}
		19	ErrorResponse(w, req, http.StatusNotFound, []HttpErrorDesc{
		20	{"en", "Not found."},
		21	{"rs", "Traženi resurs ne postoji."},
		22	})
		23	}
		24
		25	// SetDefaultHeaders set's default headers for an HTTP response.
		26	func SetDefaultHeaders(w http.ResponseWriter) {
		27	w.Header().Set("Access-Control-Allow-Origin", "*")
		28	w.Header().Set("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS")
		29	w.Header().Set("Access-Control-Allow-Headers", `Accept, Content-Type,
		30	Content-Length, Accept-Encoding, X-CSRF-Token, Authorization`)
		31	w.Header().Set("Content-Type", "application/json; charset=utf-8")
		32	}
		33
		34	// 2xx
		35	func Success(w http.ResponseWriter, payload *Payload, code int) {
		36	w.WriteHeader(code)
		37	if payload != nil {
		38	json.NewEncoder(w).Encode(*payload)
		39	}
		40	}
		41
		42	// 200
		43	func OK(w http.ResponseWriter, payload *Payload) {
		44	Success(w, payload, http.StatusOK)
		45	}
		46
		47	// 201
		48	func Created(w http.ResponseWriter, payload *Payload) {
		49	Success(w, payload, http.StatusCreated)
		50	}
		51
		52	// 4xx; 5xx
		53	func Error(w http.ResponseWriter, r *http.Request, code int, err string) {
		54	werr := webError{Error: err, Request: r.Method + " " + r.RequestURI}
		55	w.WriteHeader(code)
		56	json.NewEncoder(w).Encode(werr)
		57	}
		58
		59	// 400
		60	func BadRequest(w http.ResponseWriter, r *http.Request, err string) {
		61	Error(w, r, http.StatusBadRequest, err)
		62	}
		63
		64	// 404
		65	func NotFound(w http.ResponseWriter, r *http.Request, err string) {
		66	Error(w, r, http.StatusNotFound, err)
		67	}
		68
		69	// 401
		70	func Unauthorized(w http.ResponseWriter, r *http.Request, err string) {
		71	Error(w, r, http.StatusUnauthorized, err)
		72	}
		73
		74	// 403
		75	func Forbidden(w http.ResponseWriter, r *http.Request, err string) {
		76	Error(w, r, http.StatusForbidden, err)
		77	}
		78
		79	// 403
		80	func Conflict(w http.ResponseWriter, r *http.Request, err string) {
		81	Error(w, r, http.StatusConflict, err)
		82	}
		83
		84	// 500
		85	func InternalServerError(w http.ResponseWriter, r *http.Request, err string) {
		86	Error(w, r, http.StatusInternalServerError, err)
		87	}
		88
		89	///
		90	/// Old API
		91	///
		92
8	const (	93	const (
9	templateHttpErr500_EN = "An internal server error has occurred."	94	templateHttpErr500_EN = "An internal server error has occurred."
10	templateHttpErr500_RS = "Došlo je do greške na serveru."	95	templateHttpErr500_RS = "Došlo je do greške na serveru."
11	templateHttpErr400_EN = "Bad request."	96	templateHttpErr400_EN = "Bad request."
12	templateHttpErr400_RS = "Neispravan zahtev."	97	templateHttpErr400_RS = "Neispravan zahtev."
13	templateHttpErr404_EN = "Resource not found."	98	templateHttpErr404_EN = "Resource not found."
14	templateHttpErr404_RS = "Objekat nije pronadjen."	99	templateHttpErr404_RS = "Resurs nije pronadjen."
15	templateHttpErr401_EN = "Unauthorized request."	100	templateHttpErr401_EN = "Unauthorized request."
16	templateHttpErr401_RS = "Neautorizovan zahtev."	101	templateHttpErr401_RS = "Neautorizovan zahtev."
17	)	102	)
18		103
19	type httpError struct {	104	type httpError struct {
20	Error []HttpErrorDesc `json:"error"`	105	Error []HttpErrorDesc `json:"error"`
21	Request string `json:"request"`	106	Request string `json:"request"`
22	}	107	}
23		108
24	type HttpErrorDesc struct {	109	type HttpErrorDesc struct {
25	Lang string `json:"lang"`	110	Lang string `json:"lang"`
26	Desc string `json:"description"`	111	Desc string `json:"description"`
27	}	112	}
28		113
29	// DeliverPayload encodes payload as JSON to w.	114	// DeliverPayload encodes payload as JSON to w.
30	func DeliverPayload(w http.ResponseWriter, payload Payload) {	115	func DeliverPayload(w http.ResponseWriter, payload Payload) {
31	// Don't write status OK in the headers here. Leave it up for the caller.	116	// Don't write status OK in the headers here. Leave it up for the caller.
32	// E.g. Status 201.	117	// E.g. Status 201.
33	json.NewEncoder(w).Encode(payload)	118	json.NewEncoder(w).Encode(payload)
34	payload.Data = nil	119	payload.Data = nil
35	}	120	}
36		121
37	// ErrorResponse writes HTTP error to w.	122	// ErrorResponse writes HTTP error to w.
38	func ErrorResponse(w http.ResponseWriter, r *http.Request, code int, desc []HttpErrorDesc) {	123	func ErrorResponse(w http.ResponseWriter, r *http.Request, code int, desc []HttpErrorDesc) {
39	err := httpError{desc, r.Method + " " + r.RequestURI}	124	err := httpError{desc, r.Method + " " + r.RequestURI}
40	w.WriteHeader(code)	125	w.WriteHeader(code)
41	json.NewEncoder(w).Encode(err)	126	json.NewEncoder(w).Encode(err)
42	}	127	}
43		128
44	// NotFoundResponse writes HTTP error 404 to w.	129	// NotFoundResponse writes HTTP error 404 to w.
45	func NotFoundResponse(w http.ResponseWriter, req *http.Request) {	130	func NotFoundResponse(w http.ResponseWriter, req *http.Request) {
46	ErrorResponse(w, req, http.StatusNotFound, []HttpErrorDesc{	131	ErrorResponse(w, req, http.StatusNotFound, []HttpErrorDesc{
47	{"en", templateHttpErr404_EN},	132	{"en", templateHttpErr404_EN},
48	{"rs", templateHttpErr404_RS},	133	{"rs", templateHttpErr404_RS},
49	})	134	})
50	}	135	}
51		136
52	// BadRequestResponse writes HTTP error 400 to w.	137	// BadRequestResponse writes HTTP error 400 to w.
53	func BadRequestResponse(w http.ResponseWriter, req *http.Request) {	138	func BadRequestResponse(w http.ResponseWriter, req *http.Request) {
54	ErrorResponse(w, req, http.StatusBadRequest, []HttpErrorDesc{	139	ErrorResponse(w, req, http.StatusBadRequest, []HttpErrorDesc{
55	{"en", templateHttpErr400_EN},	140	{"en", templateHttpErr400_EN},
56	{"rs", templateHttpErr400_RS},	141	{"rs", templateHttpErr400_RS},
57	})	142	})
58	}	143	}
59		144
60	// InternalSeverErrorResponse writes HTTP error 500 to w.	145	// InternalSeverErrorResponse writes HTTP error 500 to w.
61	func InternalServerErrorResponse(w http.ResponseWriter, req *http.Request) {	146	func InternalServerErrorResponse(w http.ResponseWriter, req *http.Request) {
62	ErrorResponse(w, req, http.StatusInternalServerError, []HttpErrorDesc{	147	ErrorResponse(w, req, http.StatusInternalServerError, []HttpErrorDesc{
63	{"en", templateHttpErr500_EN},	148	{"en", templateHttpErr500_EN},
64	{"rs", templateHttpErr500_RS},	149	{"rs", templateHttpErr500_RS},
65	})	150	})
66	}	151	}
67		152
68	// UnauthorizedError writes HTTP error 401 to w.	153	// UnauthorizedError writes HTTP error 401 to w.
69	func UnauthorizedResponse(w http.ResponseWriter, req *http.Request) {	154	func UnauthorizedResponse(w http.ResponseWriter, req *http.Request) {
70	w.Header().Set("WWW-Authenticate", "Bearer")	155	w.Header().Set("WWW-Authenticate", "Bearer")
71	ErrorResponse(w, req, http.StatusUnauthorized, []HttpErrorDesc{	156	ErrorResponse(w, req, http.StatusUnauthorized, []HttpErrorDesc{
72	{"en", templateHttpErr401_EN},	157	{"en", templateHttpErr401_EN},
73	{"rs", templateHttpErr401_RS},	158	{"rs", templateHttpErr401_RS},
74	})	159	})
75	}	160	}
76

json_utility.go

Diff comments View file @9933169

 package webutility
 import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"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
 )
 var logger *gologger.Logger
 func init() {
 	var err error
 	logger, err = gologger.New("metadata", gologger.MaxLogSize100KB)
 	if err != nil {
 		fmt.Printf("webutility: %s\n", err.Error())
 	}
 }
 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 {
 	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 holds JSON payload. It can't be used for itteration.
+	// Data holds JSON payload.
+	// It can't be used for itteration.
 	Data interface{} `json:"data"`
 }
 // NewPayload returs a payload sceleton for entity described with etype.
 func NewPayload(r *http.Request, etype string) Payload {
 	pload := metadata[etype]
 	pload.Method = r.Method + " " + r.RequestURI
 	return pload
 }
 // 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)
 }
 // LoadPayloadsdetaData loads all payloads' information into 'metadata' variable.
 func LoadPayloadsMetadata(db *sql.DB, project string) error {
 	metadataDB = db
 	activeProject = project
 	mu.Lock()
 	defer mu.Unlock()
 	err := initMetadata(project)
 	if err != nil {
 		return err
 	}
 	inited = true
 	return nil
 }
 func EnableHotloading(interval int) {
 	if interval > 0 {
 		go hotload(interval)
 	}
 }
 func GetMetadataForAllEntities() map[string]Payload {
 	return metadata
 }
 func GetMetadataForEntity(t string) (Payload, bool) {
 	p, ok := metadata[t]
 	return p, ok
 }
 func QueEntityModelUpdate(entityType string, v interface{}) {
 	updateQue[entityType], _ = json.Marshal(v)
 }
 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()
 	count := 0
 	success := 0
 	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("couldn't init: '%s' metadata: %s\n%s\n", name, err.Error(), load)
 		} else {
 			success++
 			metadata[name] = p
 		}
 		count++
 	}
 	perc := float32(success/count) * 100.0
 	logger.Log("loaded %d/%d (%.1f%%) entities\n", success, count, perc)
 	return 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("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("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("couldn't refresh: '%s' metadata: %s\n%s\n", e, err.Error(), load)
 			} else {
 				metadata[e] = p
 			}
 		}
 		rows.Close()
 	}
 }
 /*
 func UpdateEntityModels(command string) (total, upd, add int, err error) {
 	if command != "force" && command != "missing" {
 		return total, 0, 0, errors.New("uknown command: " + command)
 	}
 	if !inited {
 		return 0, 0, 0, errors.New("webutil: metadata not initialized but update was tried.")
 	}
 	total = len(updateQue)
 	forUpdate := make([]string, 0)
 	forAdd := make([]string, 0)
 	for k, _ := range updateQue {
 		if _, exists := metadata[k]; exists {
 			if command == "force" {
 				forUpdate = append(forUpdate, k)
 			}
 		} else {
 			forAdd = append(forAdd, k)
 		}
 	}
 	for _, k := range forUpdate {
 		_, err := metadataDB.PrepAndExe(`update entities set
 			entity_model = :1
 			where entity_type = :2`,
 			string(updateQue[k]),
 			k)
 		if err != nil {
 			logger.Log("webutility: update metadata: prep and exe: %v\n", err)
 			continue
 		}
 		upd++
 		logger.Log("webutility: updated %s payload model\n", k)
 	}
 	blankPayload, _ := json.Marshal(Payload{})
 	for _, k := range forAdd {
 		_, err := metadataDB.PrepAndExe(`insert into entities
 			(projekat, metadata, entity_type, entity_model)
 			values(:1, :2, :3, :4)`,
 			activeProject,
 			string(blankPayload),
 			k,
 			string(updateQue[k]))
 		if err != nil {
 			logger.Log("webutility: add metadata: prep and exe: %v\n", err)
 			continue
 		}
 		metadata[k] = Payload{}
 		add++
 		logger.Log("webutility: added %s to the payload models\n", k)
 	}
 	return total, upd, add, nil
 }
 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 {
 		mu.Lock()
 		delete(metadata, entityType)
 		mu.Unlock()
 	}
 	return err
 }
 */

locale_utility.go

Diff comments View file @9933169

File was created	1	package webutility
	2
	3	import (
	4	"encoding/json"
	5	"io/ioutil"
	6	)
	7
	8	var locales = map[string]map[string]string{}
	9
	10	func LoadLocale(loc, filePath string) error {
	11	file, err := ioutil.ReadFile(filePath)
	12	if err != nil {
	13	return err
	14	}
	15
	16	var data interface{}
	17	err = json.Unmarshal(file, &data)
	18	if err != nil {
	19	return err
	20	}
	21
	22	l := map[string]string{}
	23	for k, v := range data.(map[string]interface{}) {
	24	l[k] = v.(string)
	25	}
	26	locales[loc] = l
	27
	28	return nil
	29	}
	30
	31	func Translate(loc, key string) string {
	32	return locales[loc][key]
	33	}
	34