package-installer-cli 2.2.0 → 2.3.0

data/bundle-standalone/templates/go/golang-boilerplate/model/jwt_test.go

@@ -1,28 +0,0 @@
-package model
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-)
-
-func TestJWTTokenExpirationDate(t *testing.T) {
-	jwtTime := time.Now().Add(time.Hour * 24).Round(time.Second)
-	core.AssertEqual(t, jwtTime, JWTTokenExpirationDate().Round(time.Second))
-
-	os.Setenv("JWT_TOKEN_EXPIRATION", "0")
-	jwtTime = time.Now().Add(time.Hour * 0).Round(time.Second)
-	core.AssertEqual(t, jwtTime, JWTTokenExpirationDate().Round(time.Second))
-
-	os.Setenv("JWT_TOKEN_EXPIRATION", "2")
-	jwtTime = time.Now().Add(time.Hour * 2).Round(time.Second)
-	core.AssertEqual(t, jwtTime, JWTTokenExpirationDate().Round(time.Second))
-
-	os.Setenv("JWT_TOKEN_EXPIRATION", "") // defaults to 24h if the conversion is wrong
-	jwtTime = time.Now().Add(time.Hour * 24).Round(time.Second)
-	core.AssertEqual(t, jwtTime, JWTTokenExpirationDate().Round(time.Second))
-
-	os.Setenv("JWT_TOKEN_EXPIRATION", "24")
-}

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

@@ -1,141 +0,0 @@
-package model
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/brunoksato/golang-boilerplate/util"
-	"github.com/jinzhu/gorm"
-)
-
-type Model struct {
-	ID        uint      `json:"id" gorm:"primary_key" settable:"false"`
-	CreatedAt time.Time `json:"created_at" sql:"DEFAULT:current_timestamp" settable:"false"`
-	UpdatedAt time.Time `json:"updated_at" sql:"DEFAULT:current_timestamp" settable:"false"`
-}
-
-func (m Model) OrderBy(db *gorm.DB) *gorm.DB {
-	order := "\"created_at\" DESC"
-	return db.Order(order)
-}
-
-func ParentIdField(t reflect.Type) (field *reflect.StructField, dbFieldName string) {
-	elemT := t
-	if elemT.Kind() == reflect.Ptr {
-		elemT = elemT.Elem()
-	}
-	for i := 0; i < elemT.NumField(); i++ {
-		tag := elemT.Field(i).Tag
-		if tag.Get("parent_field") != "" {
-			dbFieldName = tag.Get("parent_field")
-			fieldRef := elemT.Field(i)
-			field = &fieldRef
-		}
-	}
-	return
-}
-
-func UserIDField(t reflect.Type) (field *reflect.StructField, dbFieldName string) {
-	elemT := t
-	if elemT.Kind() == reflect.Ptr {
-		elemT = elemT.Elem()
-	}
-
-	f, found := elemT.FieldByName("UserID")
-	if found {
-		field = &f
-		dbFieldName = "user_id"
-	}
-	return
-}
-
-func OrderField(t reflect.Type) (field *reflect.StructField, dbFieldName string) {
-	elemT := t
-	if elemT.Kind() == reflect.Ptr {
-		elemT = elemT.Elem()
-	}
-	for i := 0; i < elemT.NumField(); i++ {
-		tag := elemT.Field(i).Tag
-		if tag.Get("order_field") != "" {
-			dbFieldName = tag.Get("order_field")
-			fieldRef := elemT.Field(i)
-			field = &fieldRef
-		}
-	}
-	return
-}
-
-func SetUserID(item interface{}, id uint) error {
-	v := reflect.ValueOf(item)
-	if v.Kind() == reflect.Ptr {
-		if v.IsNil() {
-			return errors.New("Cannot set value on nil item")
-		}
-		v = reflect.ValueOf(item).Elem()
-	}
-	t := v.Type()
-	if !TypeHasUserField(t) {
-		return errors.New("Type does not have a reference to a user")
-	}
-	userField, _ := UserIDField(t)
-	f := v.FieldByName(userField.Name)
-	if f.Type().Kind() == reflect.Ptr {
-		f.Set(reflect.ValueOf(&id))
-	} else {
-		f.Set(reflect.ValueOf(id))
-	}
-	return nil
-}
-
-func TypeHasParentField(t reflect.Type) bool {
-	parentField, _ := ParentIdField(t)
-	return parentField != nil
-}
-
-func TypeHasUserField(t reflect.Type) bool {
-	userField, _ := UserIDField(t)
-	return userField != nil
-}
-
-func AssertUserCan(t *testing.T, m func(ctx *ModelCtx, u User) (bool, core.DefaultError), ctx *ModelCtx, user User) {
-	can, err := m(ctx, user)
-	if err != nil {
-		t.Errorf("assertUserCan: Error occurred - %s (caller: %s)", err.Error(), util.CallerInfo())
-	}
-	if !can {
-		t.Errorf("assertUserCan: User cannot (caller: %s)", util.CallerInfo())
-	}
-}
-
-func AssertUserCant(t *testing.T, m func(ctx *ModelCtx, u User) (bool, core.DefaultError), ctx *ModelCtx, user User) {
-	can, err := m(ctx, user)
-	if err != nil {
-		t.Errorf("assertUserCant: Error occurred - %s (caller: %s)", err.Error(), util.CallerInfo())
-	}
-	if can {
-		t.Errorf("assertUserCant: User can (caller: %s)", util.CallerInfo())
-	}
-}
-
-func AssertUserCanUpdate(t *testing.T, m func(ctx *ModelCtx, u User, s []string) (bool, core.DefaultError), ctx *ModelCtx, user User, fields []string) {
-	can, err := m(ctx, user, fields)
-	if err != nil {
-		t.Errorf("assertUserCanUpdate: Error occurred - %s (caller: %s)", err.Error(), util.CallerInfo())
-	}
-	if !can {
-		t.Errorf("assertUserCanUpdate: User cannot (caller: %s)", util.CallerInfo())
-	}
-}
-
-func AssertUserCantUpdate(t *testing.T, m func(ctx *ModelCtx, u User, s []string) (bool, core.DefaultError), ctx *ModelCtx, user User, fields []string) {
-	can, err := m(ctx, user, fields)
-	if err != nil {
-		t.Errorf("assertUserCantUpdate: Error occurred - %s (caller: %s)", err.Error(), util.CallerInfo())
-	}
-	if can {
-		t.Errorf("assertUserCantUpdate: User can (caller: %s)", util.CallerInfo())
-	}
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/restrictor.go

@@ -1,19 +0,0 @@
-package model
-
-import (
-	"reflect"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-)
-
-type Restrictor interface {
-	UserCanView(ctx *ModelCtx, u User) (bool, core.DefaultError)
-	UserCanCreate(ctx *ModelCtx, u User) (bool, core.DefaultError)
-	UserCanUpdate(ctx *ModelCtx, u User, fields []string) (bool, core.DefaultError)
-	UserCanDelete(ctx *ModelCtx, u User) (bool, core.DefaultError)
-}
-
-func IsRestrictor(t reflect.Type) bool {
-	modelType := reflect.TypeOf((*Restrictor)(nil)).Elem()
-	return t.Implements(modelType)
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/restrictor_test.go

@@ -1,13 +0,0 @@
-package model
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-)
-
-func TestIsRestrictor(t *testing.T) {
-	core.AssertTrue(t, IsRestrictor(reflect.TypeOf(User{})))
-	core.AssertTrue(t, IsRestrictor(reflect.TypeOf(Configuration{})))
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/sorter.go

@@ -1,16 +0,0 @@
-package model
-
-import (
-	"reflect"
-
-	"github.com/jinzhu/gorm"
-)
-
-type Sorter interface {
-	OrderBy(*gorm.DB) *gorm.DB
-}
-
-func IsSorter(t reflect.Type) bool {
-	modelType := reflect.TypeOf((*Sorter)(nil)).Elem()
-	return t.Implements(modelType)
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/sorter_test.go

@@ -1,46 +0,0 @@
-package model
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/jinzhu/gorm"
-)
-
-func TestSorterOverriding(t *testing.T) {
-	setupDB()
-	defer teardownDB()
-	setupSorterDB()
-
-	s1 := SorterTestStruct{Order: 1}
-	s2 := SorterTestStruct{Order: 2}
-	TESTDB.Create(&s1)
-	TESTDB.Create(&s2)
-
-	var sorters []SorterTestStruct
-	db := s1.OrderBy(TESTDB)
-	db.Find(&sorters)
-	core.AssertEqual(t, 2, len(sorters))
-	core.AssertEqual(t, s1.ID, sorters[0].ID)
-	core.AssertEqual(t, s2.ID, sorters[1].ID)
-}
-
-func TestIsSorter(t *testing.T) {
-	core.AssertTrue(t, IsSorter(reflect.TypeOf(User{})))
-	core.AssertTrue(t, IsSorter(reflect.TypeOf(Configuration{})))
-}
-
-type SorterTestStruct struct {
-	Model
-	Order uint
-}
-
-func (m SorterTestStruct) OrderBy(db *gorm.DB) *gorm.DB {
-	order := "\"order\" asc"
-	return db.Order(order)
-}
-
-func setupSorterDB() {
-	TESTDB.AutoMigrate(&SorterTestStruct{})
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/test_helper.go

@@ -1,107 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/jinzhu/gorm"
-	"golang.org/x/crypto/bcrypt"
-)
-
-var INITDB *gorm.DB
-var TESTDB *gorm.DB
-var CTX *ModelCtx
-
-func startTransaction() {
-	TESTDB = INITDB.Begin()
-	CTX.Database = TESTDB
-}
-
-func teardownDB() {
-	TESTDB = TESTDB.Rollback()
-}
-
-func startDBLog() {
-	TESTDB.LogMode(true)
-}
-
-func stopDBLog() {
-	TESTDB.LogMode(false)
-}
-
-func InitTestDB() *gorm.DB {
-	if os.Getenv("TEST_DB") == "" {
-		os.Setenv("TEST_DB", "user=postgres dbname=server_test sslmode=disable")
-	} else {
-		os.Setenv("TEST_DB", os.Getenv("TEST_DB"))
-	}
-
-	var err error
-	var db *gorm.DB
-	if db, err = core.OpenTestConnection(); err != nil {
-		fmt.Println("No error should happen when connecting to test database, but got", err)
-	}
-
-	if os.Getenv("TEST_DB_LOGMODE") == "true" {
-		fmt.Println("Setting logmode to true")
-		db.LogMode(true)
-	} else {
-		db.LogMode(false)
-	}
-
-	db.DB().SetMaxIdleConns(1)
-	db.DB().SetMaxOpenConns(1)
-
-	runMigration(db)
-
-	return db
-}
-
-func runMigration(db *gorm.DB) {
-	values := []interface{}{
-		&Configuration{},
-		&User{},
-	}
-
-	for _, value := range values {
-		derr := db.DropTableIfExists(value).Error
-		if derr != nil {
-			panic(fmt.Sprintf("Error dropping table %+v ", derr))
-		}
-	}
-
-	if err := db.AutoMigrate(values...).Error; err != nil {
-		panic(fmt.Sprintf("No error should happen when create table, but got %+v", err))
-	}
-
-	db.Exec("CREATE UNIQUE INDEX idx_users_email ON users USING btree (email);")
-	db.Exec("CREATE UNIQUE INDEX idx_users_username ON users USING btree (username);")
-	db.Exec("CREATE UNIQUE INDEX idx_lower_case_username ON users ((lower(username)));")
-
-	SeedDatabase(db)
-}
-
-func DeleteAllCommitedEntities(db *gorm.DB) {
-	err := db.Delete(&Configuration{}).Error
-	if err != nil {
-		fmt.Println("Error deleting Configuration", err)
-	}
-	err = db.Unscoped().Delete(&User{}).Error
-	if err != nil {
-		fmt.Println("Error deleting User", err)
-	}
-}
-
-func SeedDatabase(db *gorm.DB) {
-	config := Configuration{
-		Model:       Model{ID: 1},
-		MinValueBuy: 25.0,
-	}
-	db.Create(&config)
-
-	password := "123456"
-	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
-	user := User{Model: Model{ID: 999}, Name: "System", Email: "system@model.com", Username: "system", HashedPassword: hashedPassword}
-	db.Create(&user)
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/updater.go

@@ -1,16 +0,0 @@
-package model
-
-import (
-	"reflect"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-)
-
-type Updater interface {
-	Update(*ModelCtx, User) core.DefaultError
-}
-
-func IsUpdater(t reflect.Type) bool {
-	modelType := reflect.TypeOf((*Updater)(nil)).Elem()
-	return t.Implements(modelType)
-}

data/bundle-standalone/templates/go/golang-boilerplate/model/updater_test.go

@@ -1,14 +0,0 @@
-package model
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-)
-
-func TestIsUpdater(t *testing.T) {
-	core.AssertTrue(t, IsUpdater(reflect.TypeOf(&User{})))
-	core.AssertFalse(t, IsUpdater(reflect.TypeOf(&Configuration{})))
-}
-

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

@@ -1,295 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"strings"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/jinzhu/gorm"
-	"github.com/sendgrid/sendgrid-go"
-	"golang.org/x/crypto/bcrypt"
-)
-
-type User struct {
-	Model
-	DeletedAt      *core.NullableTimestamp `json:"deleted_at,omitempty" settable:"false"`
-	LastLogin      *core.NullableTimestamp `json:"last_login,omitempty"`
-	Name           string                  `json:"name" sql:"not null" valid:"length(3|255),required"`
-	Username       string                  `json:"username" sql:"not null" valid:"length(3|15),matches(^[a-zA-Z0-9][a-zA-Z0-9-_]+$),required"`
-	Email          string                  `json:"email" sql:"not null" valid:"email,required"`
-	Password       string                  `json:"password,omitempty" sql:"-" valid:"length(5|64)"`
-	HashedPassword []byte                  `json:"-" sql:"hashed_password;not null" gorm:"size:32"`
-	Image          string                  `json:"image"`
-	Phone          string                  `json:"phone"`
-	Balance        float64                 `json:"balance" sql:"default:0"`
-	Admin          bool                    `json:"admin"`
-	Ban            bool                    `json:"ban"`
-}
-
-func (u User) ValidateForCreate() core.DefaultError {
-	err := u.ValidateField("name")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("username")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("email")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("password")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("phone")
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (u User) ValidateForUpdate() core.DefaultError {
-	err := u.ValidateField("name")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("email")
-	if err != nil {
-		return err
-	}
-	err = u.ValidateField("phone")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (u User) ValidateForDelete(ctx *ModelCtx) core.DefaultError {
-	return nil
-}
-
-func (u User) ValidateField(f string) core.DefaultError {
-	data := map[string]interface{}{"field": f}
-	err := ValidateStructField(u, f)
-
-	if err != nil {
-		switch f {
-		case "email":
-			if strings.Contains(err.Error(), "validate as email") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_EMAIL_FORMAT, data)
-			}
-		case "name":
-			if strings.Contains(err.Error(), "validate as matches") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_NAME_FORMAT, data)
-			} else if strings.Contains(err.Error(), "validate as length") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_NAME_LENGTH, data)
-			}
-		case "username":
-			if strings.Contains(err.Error(), "validate as matches") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_USERNAME_FORMAT, data)
-			} else if strings.Contains(err.Error(), "validate as length") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_USERNAME_LENGTH, data)
-			}
-		case "phone":
-			if strings.Contains(err.Error(), "validate as matches") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_PHONE_TAKEN, data)
-			} else if strings.Contains(err.Error(), "validate as length") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_PHONE_LENGTH, data)
-			}
-		case "password":
-			if strings.Contains(err.Error(), "validate as password") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_PASSWORD_FORMAT, data)
-			} else if strings.Contains(err.Error(), "validate as length") {
-				err = core.NewBusinessError(err.Error(), core.ERROR_SUBCODE_PASSWORD_LENGTH, data)
-			}
-		}
-	}
-
-	return err
-}
-
-// Restrictor
-
-func (u User) UserCanView(ctx *ModelCtx, viewer User) (bool, core.DefaultError) {
-	return true, nil
-}
-
-func (u User) UserCanCreate(ctx *ModelCtx, creator User) (bool, core.DefaultError) {
-	return true, nil
-}
-
-func (u User) UserCanUpdate(ctx *ModelCtx, updater User, fields []string) (bool, core.DefaultError) {
-	if u.ID == updater.ID {
-		return true, nil
-	}
-	return false, nil
-}
-
-func (u User) UserCanDelete(ctx *ModelCtx, deleter User) (bool, core.DefaultError) {
-	return deleter.IsAdmin(), nil
-}
-
-// Creator Interface
-func (u *User) Create(ctx *ModelCtx, creator User) core.DefaultError {
-	db := ctx.Database
-
-	err := u.ValidateForCreate()
-	if err != nil {
-		return err
-	}
-
-	var existing User
-	dberr := db.Scopes(ByUserEmail(u.Email)).First(&existing).Error
-	if dberr == nil {
-		data := map[string]interface{}{
-			"creator_id": creator.ID,
-			"name":       u.Name,
-			"email":      u.Email,
-		}
-		return core.NewBusinessError(
-			"email: already used;",
-			core.ERROR_SUBCODE_EMAIL_TAKEN,
-			data,
-		)
-	}
-
-	dberr = db.Scopes(ByUserUsername(u.Username)).First(&existing).Error
-	if dberr == nil {
-		data := map[string]interface{}{
-			"creator_id": creator.ID,
-			"name":       u.Name,
-			"email":      u.Email,
-		}
-		return core.NewBusinessError(
-			"username: already used;",
-			core.ERROR_SUBCODE_USERNAME_TAKEN,
-			data,
-		)
-	}
-
-	// User bcrypt to generate HashedPassword
-	u.HashedPassword, dberr = bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
-	if dberr != nil {
-		data := map[string]interface{}{
-			"creator_id": creator.ID,
-			"name":       u.Name,
-			"email":      u.Email,
-		}
-		return core.NewServerError(dberr.Error(), data)
-	}
-
-	u.Password = ""
-
-	dberr = db.Set("gorm:save_associations", false).Create(&u).Error
-	if dberr != nil {
-		data := map[string]interface{}{
-			"creator_id": creator.ID,
-			"name":       u.Name,
-			"email":      u.Email,
-		}
-		return core.NewServerError(dberr.Error(), data)
-	}
-
-	return nil
-}
-
-func (u *User) Update(ctx *ModelCtx, creator User) core.DefaultError {
-	db := ctx.Database
-
-	if u.Email != "" {
-		var existing User
-		dberr := db.Scopes(ByUserEmail(u.Email)).First(&existing).Error
-		if dberr == nil {
-			data := map[string]interface{}{
-				"creator_id": creator.ID,
-				"name":       u.Name,
-				"email":      u.Email,
-			}
-			return core.NewBusinessError(
-				"email: already used;",
-				core.ERROR_SUBCODE_EMAIL_TAKEN,
-				data,
-			)
-		}
-	}
-
-	dberr := db.Set("gorm:save_associations", false).Save(&u).Error
-	if dberr != nil {
-		data := map[string]interface{}{
-			"creator_id": creator.ID,
-			"name":       u.Name,
-			"email":      u.Email,
-		}
-		return core.NewServerError(dberr.Error(), data)
-	}
-
-	return nil
-}
-
-// Business methods
-
-func (u User) IsUser() bool {
-	return !u.Admin
-}
-
-func (u User) IsAdmin() bool {
-	return u.Admin
-}
-
-func (u User) VerifyPassword(password string) (bool, error) {
-	return bcrypt.CompareHashAndPassword(u.HashedPassword, []byte(password)) == nil, nil
-}
-
-// Scopes
-func ByUserEmail(email string) func(*gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("LOWER(users.email) = LOWER(?)", email)
-	}
-}
-
-func ByUserUsername(username string) func(*gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("LOWER(users.username) = LOWER(?)", username)
-	}
-}
-
-// email
-func (u User) ResetPasswordEmail(token string) {
-	request := sendgrid.GetRequest(os.Getenv("SENDGRID_KEY"), "/v3/mail/send", "https://api.sendgrid.com")
-	request.Method = "POST"
-	request.Body = []byte(`{
-    "personalizations": [
-			{
-				"to": [
-						{
-								"email": "` + u.Email + `"
-						}
-				],
-				"subject": "Forgot your password, ` + u.Name + `?",
-				"dynamic_template_data": {
-					"email":"` + u.Email + `",
-					"name":"` + u.Name + `",
-					"token":"` + token + `",
-				}
-			}
-    ],
-    "from": {
-			"email": "` + os.Getenv("SENDGRID_USER") + `",
-			"name": "Server"
-    },
-    "template_id" : "d-aedb512d0ca7460cadc0027d561d9c25"
-	}`)
-
-	response, err := sendgrid.API(request)
-	if err != nil {
-		log.Println(err)
-	} else {
-		fmt.Println(response.Body)
-		fmt.Println(response.Headers)
-	}
-}