push handler util model files

Author: vanhop993

handler/handler.go

@@ -0,0 +1,119 @@
+package handler
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	c "github.com/core-go/cassandra"
+	"github.com/gocql/gocql"
+	"net/http"
+)
+
+type Handler struct {
+	DB        *sql.DB
+	Session   *gocql.Session
+	Error     func(context.Context, string)
+}
+
+func NewHandler(db *sql.DB, options ...func(context.Context, string)) *Handler {
+	var logError func(context.Context, string)
+	if len(options) >= 1 {
+		logError = options[0]
+	}
+	return &Handler{DB: db, Error: logError}
+}
+
+func (h *Handler) Exec(w http.ResponseWriter, r *http.Request) {
+	s := c.JStatement{}
+	er0 := json.NewDecoder(r.Body).Decode(&s)
+	if er0 != nil {
+		http.Error(w, er0.Error(), http.StatusBadRequest)
+		return
+	}
+	s.Params = c.ParseDates(s.Params, s.Dates)
+	res, er1 := c.Exec(h.Session, s.Query, s.Params...)
+	if er1 != nil {
+		handleError(w, r, 500, er1.Error(), h.Error, er1)
+		return
+	}
+	succeed(w, r, http.StatusOK, res)
+}
+
+func (h *Handler) Query(w http.ResponseWriter, r *http.Request) {
+	s := c.JStatement{}
+	er0 := json.NewDecoder(r.Body).Decode(&s)
+	if er0 != nil {
+		http.Error(w, er0.Error(), http.StatusBadRequest)
+		return
+	}
+	s.Params = c.ParseDates(s.Params, s.Dates)
+	res, err := c.QueryMap(h.Session, s.Query, s.Params...)
+	if err != nil {
+		handleError(w, r, 500, err.Error(), h.Error, err)
+		return
+	}
+	succeed(w, r, http.StatusOK, res)
+}
+
+func (h *Handler) ExecBatch(w http.ResponseWriter, r *http.Request) {
+	var s []c.JStatement
+	b := make([]c.Statement, 0)
+	er0 := json.NewDecoder(r.Body).Decode(&s)
+	if er0 != nil {
+		http.Error(w, er0.Error(), http.StatusBadRequest)
+		return
+	}
+	l := len(s)
+	for i := 0; i < l; i++ {
+		st := c.Statement{}
+		st.Query = s[i].Query
+		st.Params = c.ParseDates(s[i].Params, s[i].Dates)
+		b = append(b, st)
+	}
+	res, err := c.ExecuteAll(r.Context(), h.Session, b...)
+	if err != nil {
+		handleError(w, r, 500, err.Error(), h.Error, err)
+		return
+	}
+	succeed(w, r, http.StatusOK, res)
+}
+
+func handleError(w http.ResponseWriter, r *http.Request, code int, result interface{}, logError func(context.Context, string), err error) {
+	if logError != nil {
+		logError(r.Context(), err.Error())
+	}
+	returnJSON(w, code, result)
+}
+func succeed(w http.ResponseWriter, r *http.Request, code int, result interface{}) {
+	response, _ := json.Marshal(result)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+	w.Write(response)
+}
+func returnJSON(w http.ResponseWriter, code int, result interface{}) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+	if result == nil {
+		w.Write([]byte("null"))
+		return nil
+	}
+	response, err := marshal(result)
+	if err != nil {
+		// log.Println("cannot marshal of result: " + err.Error())
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return err
+	}
+	w.Write(response)
+	return nil
+}
+func marshal(v interface{}) ([]byte, error) {
+	b, ok1 := v.([]byte)
+	if ok1 {
+		return b, nil
+	}
+	s, ok2 := v.(string)
+	if ok2 {
+		return []byte(s), nil
+	}
+	return json.Marshal(v)
+}

model.go

@@ -4,3 +4,8 @@ type Statement struct {
 	Query  string        `mapstructure:"query" json:"query,omitempty" gorm:"column:query" bson:"query,omitempty" dynamodbav:"query,omitempty" firestore:"query,omitempty"`
 	Params []interface{} `mapstructure:"params" json:"params,omitempty" gorm:"column:params" bson:"params,omitempty" dynamodbav:"params,omitempty" firestore:"params,omitempty"`
 }
+type JStatement struct {
+	Query  string        `mapstructure:"query" json:"query,omitempty" gorm:"column:query" bson:"query,omitempty" dynamodbav:"query,omitempty" firestore:"query,omitempty"`
+	Params []interface{} `mapstructure:"params" json:"params,omitempty" gorm:"column:params" bson:"params,omitempty" dynamodbav:"params,omitempty" firestore:"params,omitempty"`
+	Dates  []int         `mapstructure:"dates" json:"dates,omitempty" gorm:"column:dates" bson:"dates,omitempty" dynamodbav:"dates,omitempty" firestore:"dates,omitempty"`
+}

util.go

@@ -4,6 +4,16 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"time"
+)
+const (
+	t1 = "2006-01-02T15:04:05Z"
+	t2 = "2006-01-02T15:04:05-0700"
+	t3 = "2006-01-02T15:04:05.0000000-0700"
+
+	l1 = len(t1)
+	l2 = len(t2)
+	l3 = len(t3)
 )
 
 type FieldDB struct {
@@ -26,22 +36,16 @@ func CreateSchema(modelType reflect.Type) *Schema {
 	return s
 }
 func MakeSchema(modelType reflect.Type) ([]string, []string, map[string]FieldDB) {
-	numField := 0
-	if modelType.Kind() == reflect.Ptr {
-		numField = modelType.Elem().NumField()
-	} else {
-		numField = modelType.NumField()
+	m := modelType
+	if m.Kind() == reflect.Ptr {
+		m = m.Elem()
 	}
+	numField := m.NumField()
 	columns := make([]string, 0)
 	keys := make([]string, 0)
 	schema := make(map[string]FieldDB, 0)
 	for idx := 0; idx < numField; idx++ {
-		var field reflect.StructField
-		if modelType.Kind() == reflect.Ptr {
-			field = modelType.Elem().Field(idx)
-		} else {
-			field = modelType.Field(idx)
-		}
+		field := m.Field(idx)
 		tag, _ := field.Tag.Lookup("gorm")
 		if !strings.Contains(tag, IgnoreReadWrite) {
 			update := !strings.Contains(tag, "update:false")
@@ -109,3 +113,38 @@ func GetDBValue(v interface{}) (string, bool) {
 		return "", false
 	}
 }
+func ParseDates(args []interface{}, dates []int) []interface{} {
+	if args == nil || len(args) == 0 {
+		return nil
+	}
+	if dates == nil || len(dates) == 0 {
+		return args
+	}
+	res := append([]interface{}{}, args...)
+	for _, d := range dates {
+		if d >= len(args) {
+			break
+		}
+		a := args[d]
+		if s, ok := a.(string); ok {
+			switch len(s) {
+			case l1:
+				t, err := time.Parse(t1, s)
+				if err == nil {
+					res[d] = t
+				}
+			case l2:
+				t, err := time.Parse(t2, s)
+				if err == nil {
+					res[d] = t
+				}
+			case l3:
+				t, err := time.Parse(t3, s)
+				if err == nil {
+					res[d] = t
+				}
+			}
+		}
+	}
+	return res
+}