package-installer-cli 1.0.0

data/templates/go/golang-boilerplate/core/error.go

@@ -0,0 +1,144 @@
+package core
+
+import (
+	"reflect"
+
+	"github.com/brunoksato/golang-boilerplate/util"
+)
+
+type DefaultError interface {
+	Code() int
+	Subcode() int
+	Error() string
+	Location() string
+	Data() map[string]interface{}
+	IsWarning() bool
+}
+
+const ERROR_CODE_WARNING int = 300
+const ERROR_CODE_BUSINESS_ERROR int = 400
+const ERROR_CODE_AUTHENTICATION_ERROR int = 401
+const ERROR_CODE_PERMISSION_ERROR int = 403
+const ERROR_CODE_NOT_FOUND int = 404
+const ERROR_CODE_SERVER_ERROR int = 500
+
+const ERROR_SUBCODE_UNDEFINED_IGNORE int = -1000
+const ERROR_SUBCODE_UNDEFINED int = -1999
+
+const ERROR_SUBCODE_FK int = -2000
+
+const ERROR_SUBCODE_CREDENTIALS_INVALID int = -2001
+
+const ERROR_SUBCODE_EMAIL int = -2002
+const ERROR_SUBCODE_NAME_TAKEN int = -2003
+const ERROR_SUBCODE_NAME_LENGTH int = -2004
+const ERROR_SUBCODE_NAME_FORMAT int = -2005
+const ERROR_SUBCODE_EMAIL_TAKEN int = -2006
+const ERROR_SUBCODE_EMAIL_FORMAT int = -2007
+const ERROR_SUBCODE_PASSWORD_LENGTH int = -2008
+const ERROR_SUBCODE_PASSWORD_FORMAT int = -2009
+const ERROR_SUBCODE_USERNAME_TAKEN int = -2010
+const ERROR_SUBCODE_USERNAME_LENGTH int = -2011
+const ERROR_SUBCODE_USERNAME_FORMAT int = -2012
+const ERROR_SUBCODE_PHONE_TAKEN int = -2013
+const ERROR_SUBCODE_PHONE_LENGTH int = -2014
+const ERROR_SUBCODE_PHONE_FORMAT int = -2015
+
+const ERROR_SUBCODE_USER_UNDERAGE int = -2800
+const ERROR_SUBCODE_USER_LACKS_PERMISSION int = -2801
+const ERROR_SUBCODE_OTHER_USER_LACKS_PERMISSION int = -2802
+
+const ERROR_SUBCODE_DATABASE_UNAVAILABLE int = -2900
+const ERROR_SUBCODE_SERVER_OVERLOADED int = -2910
+
+type CoreError struct {
+	ErrCode     int
+	ErrSubcode  int
+	Message     string
+	ErrLocation string
+	ErrData     map[string]interface{}
+}
+
+func (err CoreError) Code() int {
+	return err.ErrCode
+}
+
+func (err CoreError) Subcode() int {
+	return err.ErrSubcode
+}
+
+func (err CoreError) Error() string {
+	return err.Message
+}
+
+func (err CoreError) Location() string {
+	return err.ErrLocation
+}
+
+func (err CoreError) Data() map[string]interface{} {
+	return err.ErrData
+}
+
+func (err CoreError) IsWarning() bool {
+	return err.ErrCode == ERROR_CODE_WARNING
+}
+
+func NewDefaultError(code, subcode int, location, msg string, data map[string]interface{}) DefaultError {
+	if subcode == 0 {
+		if code == ERROR_CODE_BUSINESS_ERROR {
+			subcode = ERROR_SUBCODE_UNDEFINED
+		} else {
+			subcode = ERROR_SUBCODE_UNDEFINED_IGNORE
+		}
+	}
+
+	err := CoreError{
+		ErrCode:     code,
+		ErrSubcode:  subcode,
+		Message:     msg,
+		ErrLocation: location,
+		ErrData:     data,
+	}
+
+	return err
+}
+
+func NewWarning(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_WARNING, msg, opts...)
+}
+
+func NewBusinessError(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_BUSINESS_ERROR, msg, opts...)
+}
+
+func NewAuthenticationError(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_AUTHENTICATION_ERROR, msg, opts...)
+}
+
+func NewPermissionError(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_PERMISSION_ERROR, msg, opts...)
+}
+
+func NewNotFoundError(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_NOT_FOUND, msg, opts...)
+}
+
+func NewServerError(msg string, opts ...interface{}) DefaultError {
+	return newElipsisError(ERROR_CODE_SERVER_ERROR, msg, opts...)
+}
+
+func newElipsisError(code int, msg string, opts ...interface{}) DefaultError {
+	subcode := 0
+	data := map[string]interface{}{}
+
+	for _, opt := range opts {
+		switch reflect.TypeOf(opt).Kind() {
+		case reflect.Int:
+			subcode = opt.(int)
+		case reflect.Map:
+			data = opt.(map[string]interface{})
+		}
+	}
+
+	return NewDefaultError(code, subcode, util.ParentCallerInfo(), msg, data)
+}

data/templates/go/golang-boilerplate/core/json.go

@@ -0,0 +1,278 @@
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func ModelToJson(model interface{}) string {
+	j, err := json.Marshal(model)
+	if err != nil {
+		panic(fmt.Sprintf("Error %v encoding JSON for %v", err, model))
+	}
+
+	jsonStr := string(j)
+	v := reflect.Indirect(reflect.ValueOf(model))
+	ot := v.Type()
+	t := ot
+	if t.Kind() == reflect.Array || t.Kind() == reflect.Slice {
+		t = t.Elem()
+	} else if t.Kind() == reflect.Interface {
+		t = v.Elem().Type()
+	}
+
+	return jsonStr
+}
+
+func ModelToJsonMap(modl interface{}) map[string]interface{} {
+	jsonStr := ModelToJson(modl)
+	m := JsonToMap(jsonStr)
+	return m
+}
+
+func JsonToMap(jsonStr string) map[string]interface{} {
+	jsonMap := make(map[string]interface{})
+
+	err := json.Unmarshal([]byte(jsonStr), &jsonMap)
+	if err != nil {
+		panic(fmt.Sprintf("Error %v unmarshaling JSON for %v", err, jsonStr))
+	}
+
+	return jsonMap
+}
+
+func JsonToMapArray(jsonStr string) []map[string]interface{} {
+	var arr []map[string]interface{}
+	err := json.Unmarshal([]byte(jsonStr), &arr)
+
+	if err != nil {
+		panic(fmt.Sprintf("Error %v unmarshaling JSON for %v", err, jsonStr))
+	}
+
+	return arr
+}
+
+func JsonToModel(jsonStr string, item interface{}) error {
+	err := json.Unmarshal([]byte(jsonStr), &item)
+
+	if err == nil {
+		v := reflect.Indirect(reflect.ValueOf(item))
+		ot := v.Type()
+		t := ot
+		if t.Kind() == reflect.Array || t.Kind() == reflect.Slice {
+			t = t.Elem()
+		} else if t.Kind() == reflect.Interface {
+			t = v.Elem().Type()
+		}
+	}
+	return err
+}
+
+func SetByJsonTag(item interface{}, jsonKey string, newVal interface{}) DefaultError {
+	data := map[string]interface{}{
+		"type": reflect.TypeOf(item),
+		"key":  jsonKey,
+		"val":  newVal,
+	}
+
+	if jsonKey == "" || jsonKey == "-" {
+		return NewBusinessError("Invalid JSON key", data)
+	}
+
+	v := reflect.ValueOf(item)
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return NewBusinessError("Cannot set value on nil item", data)
+		}
+		v = v.Elem()
+	}
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		tag := f.Tag
+		fKey := JsonName(f)
+		vField := v.Field(i)
+		if fKey == jsonKey {
+			if tag.Get("settable") == "false" {
+				return NewPermissionError("field is unsettable", data)
+			}
+			destType := vField.Type()
+			if destType.Kind() == reflect.Ptr {
+				destType = destType.Elem()
+			}
+			SetValue(vField.Addr(), destType, newVal)
+			return nil
+		}
+	}
+
+	return NewNotFoundError("field not found", data)
+}
+
+func GetFieldByJsonTag(item interface{}, jsonKey string) (field *reflect.StructField, merr DefaultError) {
+	data := map[string]interface{}{
+		"type": reflect.TypeOf(item),
+		"key":  jsonKey,
+	}
+
+	if jsonKey == "" || jsonKey == "-" {
+		return nil, NewBusinessError("Invalid JSON key", data)
+	}
+
+	v := reflect.ValueOf(item)
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return nil, NewBusinessError("Cannot set value on nil item", data)
+		}
+		v = reflect.ValueOf(item).Elem()
+	}
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		fKey := JsonName(f)
+		if fKey == jsonKey {
+			return &f, nil
+		}
+	}
+
+	return nil, NewNotFoundError("field not found", data)
+}
+
+func JsonName(f reflect.StructField) string {
+	tag := f.Tag
+	jsonTag := tag.Get("json")
+	if jsonTag == "" {
+		return ""
+	}
+
+	vals := strings.Split(jsonTag, ",")
+	return vals[0]
+}
+
+func SetValue(v reflect.Value, destType reflect.Type, newVal interface{}) {
+	vSet := v.Elem()
+
+	if vSet.Kind() == reflect.Ptr {
+		if newVal == nil {
+			vSet.Set(reflect.Zero(vSet.Type()))
+			return
+		} else {
+			floatVal, err := InterfaceToFloat64(newVal)
+			if err == nil {
+				switch destType.Kind() {
+				case reflect.Int:
+					n := int(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Int32:
+					n := int32(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Int64:
+					n := int64(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Uint:
+					n := uint(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Uint8:
+					n := uint8(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Uint16:
+					n := uint16(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Uint32:
+					n := uint32(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Uint64:
+					n := uint64(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Float32:
+					n := float32(floatVal)
+					vSet.Set(reflect.ValueOf(&n))
+				case reflect.Float64:
+					vSet.Set(reflect.ValueOf(&newVal))
+				case reflect.Struct:
+					if destType == reflect.TypeOf(NullableTimestamp{}) {
+						ts := NewNullableTimestamp(int64(floatVal))
+						vSet.Set(reflect.ValueOf(ts))
+					} else if destType == reflect.TypeOf(Timestamp{}) {
+						ts := NewTimestamp(int64(floatVal))
+						vSet.Set(reflect.ValueOf(ts))
+					}
+				default:
+					vSet.Set(reflect.ValueOf(&floatVal))
+				}
+			} else {
+				if destType.Kind() == reflect.String {
+					strVal := newVal.(string)
+					vSet.Set(reflect.ValueOf(&strVal))
+				} else if destType.Kind() == reflect.Bool {
+					boolVal := newVal.(bool)
+					vSet.Set(reflect.ValueOf(&boolVal))
+				} else {
+					vSet.Set(reflect.ValueOf(&newVal))
+				}
+			}
+		}
+	} else {
+		floatVal, err := InterfaceToFloat64(newVal)
+		if err == nil {
+			switch destType.Kind() {
+			case reflect.Int, reflect.Int32, reflect.Int64:
+				vSet.SetInt(int64(floatVal))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				vSet.SetUint(uint64(floatVal))
+			case reflect.Float32, reflect.Float64:
+				vSet.SetFloat(floatVal)
+			default:
+				vSet.Set(reflect.ValueOf(floatVal))
+			}
+		} else {
+			vSet.Set(reflect.ValueOf(newVal))
+		}
+	}
+}
+
+func InterfaceToFloat64(i interface{}) (float64, error) {
+	v := reflect.ValueOf(i)
+	switch v.Kind() {
+	case reflect.Int:
+		return float64(i.(int)), nil
+	case reflect.Uint:
+		return float64(i.(uint)), nil
+	case reflect.Uint64:
+		return float64(i.(uint64)), nil
+	case reflect.Int32:
+		return float64(i.(int32)), nil
+	case reflect.Int64:
+		return float64(i.(int64)), nil
+	case reflect.Float32:
+		return float64(i.(float32)), nil
+	case reflect.Float64:
+		return i.(float64), nil
+	default:
+		return 0, fmt.Errorf("not implemented for type %v", v.Kind())
+	}
+}
+
+func IsJsonEnabled(f reflect.StructField, apiType APIType) bool {
+	enabled := false
+
+	tag := f.Tag
+	jsonField := tag.Get("json")
+	if jsonField != "" {
+		sensitive := false
+		matches := false
+		vals := strings.Split(jsonField, ",")
+		for j := 1; j < len(vals); j++ {
+			val := vals[j]
+			if val == "user" || val == "admin" {
+				sensitive = true
+				matches = matches || val == "user" && apiType == USER_API
+				matches = matches || val == "admin" && apiType == ADMIN_API
+			}
+		}
+		enabled = matches || !sensitive
+	}
+
+	return enabled
+}

data/templates/go/golang-boilerplate/core/test.go

@@ -0,0 +1,237 @@
+package core
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/brunoksato/golang-boilerplate/util"
+	"github.com/jinzhu/gorm"
+	_ "github.com/jinzhu/gorm/dialects/postgres"
+	"github.com/labstack/echo/v4"
+)
+
+func OpenTestConnection() (db *gorm.DB, err error) {
+	testDB := os.Getenv("SERVER_DB")
+	if testDB == "" {
+		testDB = "user=postgres dbname=server_test sslmode=disable"
+	}
+	db, err = gorm.Open("postgres", testDB)
+	return
+}
+
+// Rest Test
+func typeTestHandler(c echo.Context) {
+	parent := expectedTypeName(c.Get("ParentType").(reflect.Type))
+	child := expectedTypeName(c.Get("Type").(reflect.Type))
+
+	fmt.Fprintf(c.Response(), "Parent Type: %s, Type: %s", parent, child)
+}
+
+func expectedTypeName(t reflect.Type) (expected string) {
+	if t == nil {
+		expected = "nil"
+	} else {
+		expected = t.Name()
+	}
+	return
+}
+
+func NewTestRequest(method, path string) (*httptest.ResponseRecorder, *http.Request) {
+	request, err := http.NewRequest(method, path, nil)
+	request.Header.Set("X-Company", "Office")
+	request.Header.Add("Content-Type", "application/json")
+	if err != nil {
+		fmt.Println("Error configuring test request:", err)
+	}
+	recorder := httptest.NewRecorder()
+
+	return recorder, request
+}
+
+func NewTestPost(method, path string, body interface{}) (*httptest.ResponseRecorder, *http.Request) {
+	jsonStr := ModelToJson(body)
+	bodyStr := bytes.NewBufferString(jsonStr)
+	request, err := http.NewRequest(method, path, bodyStr)
+	request.Header.Set("X-Company", "Office")
+	request.Header.Add("Content-Type", "application/json")
+	if err != nil {
+		fmt.Println("Error configuring test request:", err)
+	}
+	recorder := httptest.NewRecorder()
+
+	return recorder, request
+}
+
+func NewTestForm(path string, params map[string]interface{}) (*httptest.ResponseRecorder, *http.Request) {
+	values := url.Values{}
+	for k, v := range params {
+		values.Set(k, fmt.Sprintf("%v", v))
+	}
+
+	// Can't seem to get this working. So, for now...
+	querypath := fmt.Sprintf("%s?%s", path, values.Encode())
+	recorder, request := NewTestRequest("POST", querypath)
+
+	return recorder, request
+}
+
+// Assert methods
+
+func AssertResponse(t *testing.T, rr *httptest.ResponseRecorder, body string, code int) {
+	if gotBody := strings.TrimSpace(string(rr.Body.Bytes())); body != gotBody {
+		t.Errorf("assertResponse: expected body to be %s but got %s. (caller: %s)", body, gotBody, util.CallerInfo())
+	}
+	AssertResponseCode(t, rr, code)
+}
+
+func AssertResponseCode(t *testing.T, rr *httptest.ResponseRecorder, code int) {
+	if code != rr.Code {
+		t.Errorf("assertResponse: expected code to be %d but got %d. (caller: %s)", code, rr.Code, util.CallerInfo())
+	}
+}
+
+func AssertEqual(t *testing.T, expected, actual interface{}) {
+	if !reflect.DeepEqual(expected, actual) {
+		kind := reflect.ValueOf(expected).Kind()
+		if kind == reflect.Map {
+			if mExp, ok := expected.(map[string]interface{}); ok {
+				mAct := actual.(map[string]interface{})
+				for key, value := range mExp {
+					AssertEqual(t, value, mAct[key])
+				}
+			} else if mExp, ok := expected.(map[float32][]uint); ok {
+				mAct := actual.(map[float32][]uint)
+				for key, value := range mExp {
+					AssertEqual(t, value, mAct[key])
+				}
+			} else {
+				mExp := expected.(map[uint]uint)
+				mAct := actual.(map[uint]uint)
+				for key, value := range mExp {
+					AssertEqual(t, value, mAct[key])
+				}
+			}
+		} else if kind == reflect.Array || kind == reflect.Slice {
+			eVal := reflect.ValueOf(expected)
+			aVal := reflect.ValueOf(actual)
+			AssertEqual(t, eVal.Len(), aVal.Len())
+			for i := 0; i < aVal.Len(); i++ {
+				AssertEqual(t, eVal.Index(i).Interface(), aVal.Index(i).Interface())
+			}
+		}
+	}
+}
+
+func AssertNil(t *testing.T, actual interface{}) {
+	if actual != nil && !reflect.ValueOf(actual).IsNil() {
+		t.Errorf("assertNil: Expected nil value, but got:\n%v\n (caller: %s)", actual, CallerInfo())
+	}
+}
+func AssertNotNil(t *testing.T, actual interface{}) {
+	if actual == nil || reflect.ValueOf(actual).IsNil() {
+		t.Errorf("assertNotNil: Expected object to not be nil (caller: %s)", CallerInfo())
+	}
+}
+func AssertZeroStruct(t *testing.T, actual interface{}) {
+	if !util.IsZeroStruct(actual) {
+		t.Errorf("assertZeroStruct: Expected zero struct, but got:\n%v\n (caller: %s)", actual, CallerInfo())
+	}
+}
+func AssertFalse(t *testing.T, result bool) {
+	if result {
+		t.Errorf("assertFalse: Assertion is true (caller: %s)", CallerInfo())
+	}
+}
+func AssertTrue(t *testing.T, result bool) {
+	if !result {
+		t.Errorf("assertTrue: Assertion is false (caller: %s)", CallerInfo())
+	}
+}
+
+func AssertNoError(t *testing.T, err error) {
+	if err != nil {
+		t.Errorf("assertNoError: Expected no error, but received message: %s (caller: %s)", err, CallerInfo())
+	}
+}
+
+func AssertWarning(t *testing.T, msg string, err DefaultError) {
+	AssertDefaultError(t, "Warning", msg, err, CallerInfo())
+}
+
+func AssertBusinessError(t *testing.T, msg string, err DefaultError) {
+	AssertDefaultError(t, "Business Error", msg, err, CallerInfo())
+}
+
+func AssertPermissionError(t *testing.T, msg string, err DefaultError) {
+	AssertDefaultError(t, "Permission Error", msg, err, CallerInfo())
+}
+
+func AssertNotFoundError(t *testing.T, msg string, err DefaultError) {
+	AssertDefaultError(t, "Not Found Error", msg, err, CallerInfo())
+}
+
+func AssertServerError(t *testing.T, msg string, err DefaultError) {
+	AssertDefaultError(t, "Server Error", msg, err, CallerInfo())
+}
+
+func AssertDefaultError(t *testing.T, prefix, msg string, err DefaultError, callerInfo string) {
+	if err == nil {
+		t.Errorf("AssertDefaultError: Expected an error, but it was nil (caller: %s)", callerInfo)
+		return
+	}
+
+	if _, ok := err.(DefaultError); !ok {
+		t.Errorf("AssertDefaultError: Expected a petmondo error, but got: %s (caller: %s)", err, callerInfo)
+		return
+	}
+
+	errMsg := err.Error()
+
+	idx := strings.Index(errMsg, "(caller:")
+	if idx != -1 {
+		errMsg = errMsg[:idx-1]
+	}
+
+	if msg != errMsg {
+		t.Errorf("AssertDefaultError: Expected error \"%s\", but got \"%s\" (caller: %s)", msg, errMsg, callerInfo)
+		return
+	}
+}
+
+func LineInfo() string {
+	_, file, line, ok := runtime.Caller(1)
+	if !ok {
+		return ""
+	}
+	parts := strings.Split(file, "/")
+	file = parts[len(parts)-1]
+	return fmt.Sprintf("%s:%d", file, line)
+}
+
+func CallerInfo() string {
+	_, file, line, ok := runtime.Caller(2)
+	if !ok {
+		return ""
+	}
+	parts := strings.Split(file, "/")
+	file = parts[len(parts)-1]
+	return fmt.Sprintf("%s:%d", file, line)
+}
+
+func ParentCallerInfo() string {
+	_, file, line, ok := runtime.Caller(3)
+	if !ok {
+		return ""
+	}
+	parts := strings.Split(file, "/")
+	file = parts[len(parts)-1]
+	return fmt.Sprintf("%s:%d", file, line)
+}