package-installer-cli 2.1.0 → 2.3.0

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

@@ -1,278 +0,0 @@
-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/bundle-standalone/templates/go/golang-boilerplate/core/test.go

@@ -1,237 +0,0 @@
-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)
-}

data/bundle-standalone/templates/go/golang-boilerplate/core/timestamp.go

@@ -1,111 +0,0 @@
-package core
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"strconv"
-	"time"
-
-	"github.com/brunoksato/golang-boilerplate/util"
-)
-
-type Timestamp struct {
-	Time time.Time
-}
-
-// Value implements the driver Valuer interface.
-func (ts Timestamp) Value() (driver.Value, error) {
-	return ts.Time, nil
-}
-
-func (ts *Timestamp) Scan(value interface{}) error {
-	ts.Time = value.(time.Time)
-	return nil
-}
-
-func (ts Timestamp) MarshalJSON() ([]byte, error) {
-	return json.Marshal(int64(ts.Timestamp()))
-}
-
-func (ts *Timestamp) UnmarshalJSON(data []byte) error {
-	tsInt, err := strconv.Atoi(string(data))
-	if err != nil {
-		return err
-	}
-	ts.SetTimestamp(int64(tsInt))
-	return nil
-}
-
-func (ts Timestamp) Timestamp() int64 {
-	return util.NanoToMicro(ts.Time.UnixNano())
-}
-
-func (ts *Timestamp) SetTimestamp(val int64) {
-	ts.Time = time.Unix(0, util.MicroToNano(val))
-}
-
-func NewTimestamp(val int64) Timestamp {
-	t := time.Unix(0, util.MicroToNano(val))
-	return Timestamp{Time: t}
-}
-
-type NullableTimestamp struct {
-	Time time.Time
-}
-
-// Value implements the driver Valuer interface.
-func (ts *NullableTimestamp) Value() (driver.Value, error) {
-	if ts == nil {
-		return nil, nil
-	}
-
-	return ts.Time, nil
-}
-
-func (ts *NullableTimestamp) Scan(value interface{}) error {
-	if ts == nil {
-		return nil
-	} else {
-		if value != nil {
-			t := value.(time.Time)
-			ts.Time = t
-		}
-	}
-	return nil
-}
-
-func (ts *NullableTimestamp) MarshalJSON() ([]byte, error) {
-	if ts == nil {
-		return []byte("null"), nil
-	}
-
-	return json.Marshal(int64(ts.Timestamp()))
-}
-
-func (ts *NullableTimestamp) UnmarshalJSON(data []byte) error {
-	if ts == nil {
-		return nil
-	} else {
-		if len(data) > 0 {
-			tsInt, err := strconv.Atoi(string(data))
-			if err != nil {
-				return err
-			}
-			ts.SetTimestamp(int64(tsInt))
-		}
-	}
-	return nil
-}
-
-func (ts NullableTimestamp) Timestamp() int64 {
-	return util.NanoToMicro(ts.Time.UnixNano())
-}
-
-func (ts *NullableTimestamp) SetTimestamp(val int64) {
-	ts.Time = time.Unix(0, util.MicroToNano(val))
-}
-
-func NewNullableTimestamp(val int64) *NullableTimestamp {
-	t := time.Unix(0, util.MicroToNano(val))
-	return &NullableTimestamp{Time: t}
-}

data/bundle-standalone/templates/go/golang-boilerplate/core/type.go

@@ -1,7 +0,0 @@
-package core
-
-type APIType string
-
-const USER_API APIType = "USER_API"
-const CRONJOB_API APIType = "CRONJOB_API"
-const ADMIN_API APIType = "ADMIN_API"

data/bundle-standalone/templates/go/golang-boilerplate/db/dbconf.yml

@@ -1,17 +0,0 @@
-development:
-  driver: postgres
-  open: dbname=server sslmode=disable
-
-staging:
-  driver: postgres
-  open: host=you_host user=you_user dbname=you_db password=you_password
-
-production:
-  driver: postgres
-  open: host=you_host user=you_user dbname=you_db password=you_password
-
-test:
-  driver: postgres
-  open: user=postgres dbname=server_test sslmode=disable
-
-#open: $DATABASE_URL

data/bundle-standalone/templates/go/golang-boilerplate/db/migrations/20190611174624_base.sql

@@ -1,42 +0,0 @@
-
--- +goose Up
--- SQL in section 'Up' is executed when this migration is applied
-
-
-create table configurations(
-	id serial not null,
-	created_at timestamp with time zone DEFAULT now(),
-  updated_at timestamp with time zone DEFAULT now(),
-  min_value_buy numeric(12,2),
-);
-ALTER TABLE ONLY configurations ADD CONSTRAINT configurations_pkey PRIMARY KEY (id);
-
-CREATE TABLE users(
-	id serial not null,
-	created_at timestamp with time zone DEFAULT now(),
-  updated_at timestamp with time zone DEFAULT now(),
-  deleted_at timestamp with time zone,
-  last_login timestamp with time zone,
-  hashed_password bytea NOT NULL,
-  password varchar(255),
-  image varchar(255),
-  phone varchar(255),
-	name varchar(255) not null,
-	username varchar(50) not null,
-	email varchar(100) not null,
-	balance numeric(12,2) default 0,
-	admin boolean not null default false,
-	ban boolean not null default false,
-);
-
-ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id);
-CREATE UNIQUE INDEX idx_users_email ON users USING btree (email);
-CREATE UNIQUE INDEX idx_users_username ON users USING btree (username);
-CREATE UNIQUE INDEX idx_lower_case_username ON users ((lower(username)));
-
-
--- +goose Down
--- SQL section 'Down' is executed when this migration is rolled back
-
-DROP TABLE configurations;
-DROP TABLE users;

data/bundle-standalone/templates/go/golang-boilerplate/db/seed.sql

@@ -1 +0,0 @@
-insert into configurations (min_value_buy) values (1);