package-installer-cli 2.1.0 → 2.3.0

data/bundle-standalone/templates/go/golang-boilerplate/api/user.go

@@ -1,80 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	log "github.com/brunoksato/golang-boilerplate/log"
-	"github.com/brunoksato/golang-boilerplate/model"
-	"github.com/labstack/echo/v4"
-	"golang.org/x/crypto/bcrypt"
-)
-
-func Logout(c echo.Context) error {
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "OK"})
-}
-
-func Me(c echo.Context) error {
-	ctx := ServerContext(c)
-	ctx.Payload["results"] = ctx.User
-	return c.JSON(http.StatusOK, ctx.Payload)
-}
-
-func ChangePassword(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	type customPassword struct {
-		Password string `json:"password"`
-	}
-
-	u := new(customPassword)
-	if err := c.Bind(&u); err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	user := model.User{}
-	err := db.First(&user, ctx.User.ID).Error
-	if err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	user.HashedPassword, _ = bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
-
-	serr := db.Model(&user).Set("gorm:save_associations", false).UpdateColumn("hashed_password", user.HashedPassword).Error
-	if serr != nil {
-		return log.AddDefaultError(c, core.NewServerError(serr.Error()))
-	}
-
-	return c.JSON(http.StatusOK, user)
-}
-
-func UpdateUser(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	user := model.User{}
-	err := db.First(&user, ctx.User.ID).Error
-	if err != nil {
-		return log.AddDefaultError(c, core.NewNotFoundError(err.Error()))
-	}
-
-	if err := c.Bind(&user); err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	dberr := db.
-		Model(&user).
-		Set("gorm:save_associations", false).
-		Updates(map[string]interface{}{
-			"name":  user.Name,
-			"email": user.Email,
-			"phone": user.Phone,
-			"image": user.Image,
-		}).Error
-	if dberr != nil {
-		return log.AddDefaultError(c, core.NewServerError(dberr.Error()))
-	}
-
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "OK"})
-}

data/bundle-standalone/templates/go/golang-boilerplate/api/user_test.go

@@ -1,43 +0,0 @@
-package api_test
-
-import (
-	"testing"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/brunoksato/golang-boilerplate/model"
-	"github.com/stretchr/testify/assert"
-	"golang.org/x/crypto/bcrypt"
-)
-
-func TestUserDirects(t *testing.T) {
-	setup()
-	defer teardown()
-	router := router()
-
-	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("123456"), bcrypt.DefaultCost)
-
-	u1 := model.User{Name: "User1", Phone: "12982573000", Email: "user1@model.com", Username: "user1", HashedPassword: hashedPassword}
-	u2 := model.User{Name: "User2", Phone: "12982573000", Email: "user2@model.com", Username: "user2", HashedPassword: hashedPassword}
-	u3 := model.User{Name: "User3", Phone: "12982573000", Email: "user3@model.com", Username: "user3", HashedPassword: hashedPassword}
-	u4 := model.User{Name: "User4", Phone: "12982573000", Email: "user4@model.com", Username: "user4", HashedPassword: hashedPassword}
-	TESTDB.Create(&u1)
-	TESTDB.Create(&u2)
-	TESTDB.Create(&u3)
-	TESTDB.Create(&u4)
-	u5 := model.User{Name: "User5", Email: "user5@model.com", Username: "user5", HashedPassword: hashedPassword}
-	u6 := model.User{Name: "User6", Email: "user6@model.com", Username: "user6", HashedPassword: hashedPassword}
-	TESTDB.Create(&u5)
-	TESTDB.Create(&u6)
-
-	rw, req := core.NewTestRequest("GET", "/api/users/directs")
-	router.ServeHTTP(rw, req)
-	core.AssertResponseCode(t, rw, 200)
-
-	actualInt := core.JsonToMap(rw.Body.String())
-	actual := actualInt["results"].([]interface{})
-	assert.Equal(t, 4, len(actual))
-	assert.Equal(t, actual[0].(map[string]interface{})["username"], "user1")
-	assert.Equal(t, actual[1].(map[string]interface{})["username"], "user2")
-	assert.Equal(t, actual[2].(map[string]interface{})["username"], "user3")
-	assert.Equal(t, actual[3].(map[string]interface{})["username"], "user4")
-}

data/bundle-standalone/templates/go/golang-boilerplate/api/webhook.go

@@ -1,33 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	log "github.com/brunoksato/golang-boilerplate/log"
-	"github.com/labstack/echo/v4"
-)
-
-func WebhookSample(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-	tx := db.Begin()
-
-	ctx.Logger.Info("WebhookSample Start")
-
-	if err := tx.Error; err != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	event := map[string]interface{}{}
-	if err := c.Bind(&event); err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	tx.Commit()
-
-	ctx.Logger.Info("WebhookSample End")
-
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "ok"})
-}

data/bundle-standalone/templates/go/golang-boilerplate/config/config.go

@@ -1,137 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/brunoksato/golang-boilerplate/log"
-	"github.com/jinzhu/gorm"
-	_ "github.com/jinzhu/gorm/dialects/postgres"
-	elastic "github.com/olivere/elastic"
-	"go.elastic.co/apm/module/apmgorm"
-)
-
-var CONFIGURATIONS map[string]string = map[string]string{
-	"SERVER_ENV":            "development",
-	"SERVER_NAME":           "SERVER",
-	"DATABASE_URL":          "dbname=server sslmode=disable",
-	"AWS_ACCESS_KEY":        "",
-	"AWS_ACCESS_KEY_SECRET": "",
-	"AWS_REGION":            "us-east-1",
-	"AWS_BUCKET":            "development.company.asset",
-	"ES_HOST":               "localhost:9200",
-	"LOGGER_LEVEL":          "info",
-	"SENDGRID_KEY":          "key_sendgrid",
-	"SENDGRID_USER":         "support@company.com",
-	"JWT_KEY_SIGNIN":        "you_secret_key",
-	"JWT_KEY_EMAIL":         "you_secret_key_email",
-	"JWT_TOKEN_EXPIRATION":  "72",
-}
-
-func Init() {
-	if os.Getenv("SERVER_ENV") == "" {
-		os.Setenv("SERVER_ENV", CONFIGURATIONS["SERVER_ENV"])
-	}
-	if os.Getenv("SERVER_NAME") == "" {
-		os.Setenv("SERVER_NAME", CONFIGURATIONS["SERVER_NAME"])
-	}
-	if os.Getenv("DATABASE_URL") == "" {
-		os.Setenv("DATABASE_URL", CONFIGURATIONS["DATABASE_URL"])
-	}
-	if os.Getenv("AWS_ACCESS_KEY") == "" {
-		os.Setenv("AWS_ACCESS_KEY", CONFIGURATIONS["AWS_ACCESS_KEY"])
-	}
-	if os.Getenv("AWS_ACCESS_KEY_SECRET") == "" {
-		os.Setenv("AWS_ACCESS_KEY_SECRET", CONFIGURATIONS["AWS_ACCESS_KEY_SECRET"])
-	}
-	if os.Getenv("AWS_REGION") == "" {
-		os.Setenv("AWS_REGION", CONFIGURATIONS["AWS_REGION"])
-	}
-	if os.Getenv("AWS_BUCKET") == "" {
-		os.Setenv("AWS_BUCKET", CONFIGURATIONS["AWS_BUCKET"])
-	}
-	if os.Getenv("ES_HOST") == "" {
-		os.Setenv("ES_HOST", CONFIGURATIONS["ES_HOST"])
-	}
-	if os.Getenv("LOGGER_LEVEL") == "" {
-		os.Setenv("LOGGER_LEVEL", CONFIGURATIONS["LOGGER_LEVEL"])
-	}
-	if os.Getenv("SENDGRID_KEY") == "" {
-		os.Setenv("SENDGRID_KEY", CONFIGURATIONS["SENDGRID_KEY"])
-	}
-	if os.Getenv("SENDGRID_USER") == "" {
-		os.Setenv("SENDGRID_USER", CONFIGURATIONS["SENDGRID_USER"])
-	}
-	if os.Getenv("JWT_KEY_SIGNIN") == "" {
-		os.Setenv("JWT_KEY_SIGNIN", CONFIGURATIONS["JWT_KEY_SIGNIN"])
-	}
-	if os.Getenv("JWT_KEY_EMAIL") == "" {
-		os.Setenv("JWT_KEY_EMAIL", CONFIGURATIONS["JWT_KEY_EMAIL"])
-	}
-	if os.Getenv("JWT_TOKEN_EXPIRATION") == "" {
-		os.Setenv("JWT_TOKEN_EXPIRATION", CONFIGURATIONS["JWT_TOKEN_EXPIRATION"])
-	}
-}
-
-func InitDB() *gorm.DB {
-	if os.Getenv("DATABASE_URL") == "" {
-		os.Setenv("DATABASE_URL", CONFIGURATIONS["DATABASE_URL"])
-	}
-
-	db, err := apmgorm.Open("postgres", os.Getenv("DATABASE_URL"))
-	if err != nil {
-		panic(err.Error())
-	}
-
-	fmt.Println(fmt.Sprintf("Initialized read-write database connection pool: %s", os.Getenv("DATABASE_URL")))
-	return db
-}
-
-func InitElasticSearchAndLogger() (client *elastic.Client) {
-	logrus.SetFormatter(&log.LogstashFormatter{})
-	// Acceptable values are:
-	// debug, info, warn, error, fatal, panic
-	level := os.Getenv("LOGGER_LEVEL")
-	if level != "" {
-		l, err := logrus.ParseLevel(level)
-		if err == nil {
-			logrus.SetLevel(l)
-		} else {
-			fmt.Println("Error with log level configuraion:", err)
-		}
-	}
-
-	appName := fmt.Sprintf("%s-%s", os.Getenv("NAME"), os.Getenv("ENV"))
-	esHostname := os.Getenv("ES_HOST")
-	thisHostname, _ := os.Hostname()
-
-	if esHostname != "" {
-		var esURL string
-		if strings.Contains(esHostname, "127.0.0.1") {
-			esURL = fmt.Sprintf("http://%s", esHostname)
-		} else {
-			esURL = fmt.Sprintf("https://%s", esHostname)
-		}
-		fmt.Println(fmt.Sprintf("Configuring elasticsearch logging: %s", esURL))
-		client, err := elastic.NewClient(elastic.SetSniff(false), elastic.SetURL(esURL))
-		if err != nil {
-			fmt.Println(fmt.Sprintf("Error configuring elasticsearch logging: %s", err.Error()))
-		} else {
-			now := time.Now()
-			appName = fmt.Sprintf("logstash-%d.%d.%d", now.Year(), now.Month(), now.Day())
-			hook, err := log.NewElasticHook(client, thisHostname, logrus.DebugLevel, appName)
-			if err == nil {
-				logrus.AddHook(hook)
-			} else {
-				fmt.Println(fmt.Sprintf("Error configuring logger for elastic search: %s", err.Error()))
-			}
-		}
-
-		return client
-	}
-
-	return
-}

data/bundle-standalone/templates/go/golang-boilerplate/config/config_test.go

@@ -1 +0,0 @@
-package config

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

@@ -1,161 +0,0 @@
-package core
-
-import (
-	"errors"
-	"reflect"
-	"strings"
-
-	"github.com/jinzhu/gorm"
-)
-
-func DefaultPreloads(db *gorm.DB, t reflect.Type, api APIType, skipParent bool) func(*gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		elemT := t
-		if elemT.Kind() == reflect.Ptr {
-			elemT = elemT.Elem()
-		}
-		for i := 0; i < elemT.NumField(); i++ {
-			f := elemT.Field(i)
-			ft := f.Type
-			if ft.Kind() == reflect.Ptr {
-				ft = ft.Elem()
-			}
-
-			preload := false
-			all := false
-			skip := false
-			fieldName := f.Name
-			tag := elemT.Field(i).Tag
-
-			if skipParent {
-				if _, ok := tag.Lookup("parent"); ok {
-					continue
-				}
-			}
-
-			fetch, _ := tag.Lookup("fetch")
-			fetchConfigs := strings.Split(fetch, ",")
-			for _, config := range fetchConfigs {
-				switch config {
-				case "user":
-					if api == USER_API {
-						preload = true
-					}
-				case "admin":
-					if api == ADMIN_API {
-						preload = true
-					}
-				case "eager":
-					preload = true
-				case "all":
-					all = true
-				case "parent":
-					skip = skipParent
-				default:
-					fieldName = config
-				}
-			}
-			if skip {
-				preload = false
-			}
-			if preload {
-				if all {
-					db = db.Preload(fieldName, func(db *gorm.DB) *gorm.DB {
-						return db.Unscoped()
-					})
-				} else {
-					db = db.Preload(fieldName)
-				}
-			}
-
-		}
-		return db
-	}
-}
-
-func PageQueryResults(start, limit *uint) func(*gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		if start != nil && *start != 0 {
-			db = db.Offset(*start)
-		}
-		if limit != nil && *limit != 0 {
-			db = db.Limit(*limit)
-		}
-		return db
-	}
-}
-
-func UpdateField(db *gorm.DB, item interface{}, field string, value interface{}) DefaultError {
-	if item == nil {
-		return NewServerError("Trying to update field on nil object")
-	}
-
-	if reflect.ValueOf(item).Kind() != reflect.Ptr {
-		return NewServerError("Trying to update field on non-pointer object")
-	}
-
-	id, err := GetID(item)
-	if err != nil {
-		return NewServerError(err.Error())
-	}
-
-	if id > 0 {
-		err = db.Set("gorm:save_associations", false).Model(item).Update(field, value).Error
-		if err != nil {
-			return NewServerError(err.Error())
-		}
-		return nil
-	}
-
-	return NewServerError("Trying to update field on empty object")
-}
-
-func UpdateFields(db *gorm.DB, item interface{}, transitive interface{}) DefaultError {
-	if item == nil {
-		return NewServerError("Trying to update fields on nil object")
-	}
-
-	if reflect.ValueOf(item).Kind() != reflect.Ptr {
-		return NewServerError("Trying to update fields on non-pointer object")
-	}
-
-	id, err := GetID(item)
-	if err != nil {
-		return NewServerError(err.Error())
-	}
-
-	if id > 0 {
-		err = db.Set("gorm:save_associations", false).Model(item).Updates(transitive).Error
-		if err != nil {
-			return NewServerError(err.Error())
-		}
-		return nil
-	}
-
-	return NewServerError("Trying to update fields on empty object")
-}
-
-func GetID(item interface{}) (uint, error) {
-	v := reflect.ValueOf(item)
-	if v.Kind() == reflect.Ptr {
-		if v.IsNil() {
-			return 0, errors.New("Cannot get value from nil item")
-		}
-		v = reflect.ValueOf(item).Elem()
-	}
-	f := v.FieldByName("ID")
-	parentID := uint(f.Uint())
-	return parentID, nil
-}
-
-func TableNameFor(t reflect.Type) string {
-	name := gorm.ToDBName(t.Name())
-	if strings.HasSuffix(name, "y") {
-		name = name[:len(name)-1] + "ies"
-	} else if strings.HasSuffix(name, "ss") {
-		name = name + "es"
-	} else {
-		name = name + "s"
-	}
-	return name
-}

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

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