package-installer-cli 2.2.0 → 2.3.0

data/bundle-standalone/templates/go/golang-boilerplate/Dockerfile

@@ -1,25 +0,0 @@
-FROM golang:1.12.5-alpine as builder
-
-ARG COMMIT_REF
-ARG BUILD_DATE
-
-ENV APP_COMMIT_REF=${COMMIT_REF} \
-    APP_BUILD_DATE=${BUILD_DATE}
-
-RUN apk update && apk upgrade && \
-    apk add --no-cache bash git openssh g++ glide ca-certificates
-
-RUN adduser -D -g '' appuser
-
-RUN mkdir -p /go/src/github.com/brunoksato/golang-boilerplate
-ADD . /go/src/github.com/brunoksato/golang-boilerplate
-WORKDIR /go/src/github.com/brunoksato/golang-boilerplate
-RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o golang-boilerplate .
-
-FROM scratch
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
-COPY --from=builder /etc/passwd /etc/passwd
-COPY --from=builder /go/src/github.com/brunoksato/golang-boilerplate/golang-boilerplate /app/
-WORKDIR /app
-EXPOSE 8080
-CMD ["./golang-boilerplate"]

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

@@ -1,176 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"os"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	log "github.com/brunoksato/golang-boilerplate/log"
-	"github.com/brunoksato/golang-boilerplate/model"
-	"github.com/dgrijalva/jwt-go"
-	"github.com/labstack/echo/v4"
-	"golang.org/x/crypto/bcrypt"
-)
-
-func SignUp(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-	tx := db.Begin()
-
-	if err := tx.Error; err != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	user := model.User{}
-	if err := c.Bind(&user); err != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	cerr := user.Create(ArgonContextTransaction(c, tx), ctx.User)
-	if cerr != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, cerr)
-	}
-
-	err := tx.Where("email = ?", user.Email).Find(&user).Error
-	if err != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	tx.Commit()
-
-	ctx.Payload["results"] = user
-	return c.JSON(http.StatusCreated, ctx.Payload)
-}
-
-func SignIn(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	u := model.User{}
-	if err := c.Bind(&u); err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	if u.Username != "" {
-		if err := db.Where("username = ?", u.Username).Find(&ctx.User).Error; err != nil {
-			return log.AddDefaultError(c, core.NewServerError(err.Error()))
-		}
-
-		if ctx.APIType == core.ADMIN_API && !ctx.User.IsAdmin() {
-			return c.JSON(http.StatusUnauthorized, map[string]interface{}{"status": "Not Authorized"})
-		}
-
-		if ok, _ := ctx.User.VerifyPassword(u.Password); ok {
-			expireAt := model.JWTTokenExpirationDate()
-
-			jwt, dberr := model.IssueJWToken(ctx.User.ID, []string{"user"}, expireAt)
-			if dberr != nil {
-				return log.AddDefaultError(c,
-					core.NewServerError(
-						dberr.Error(),
-						map[string]interface{}{
-							"user_id": ctx.User.ID,
-						},
-					),
-				)
-			}
-
-			ctx.Payload["results"] = ctx.User
-			ctx.Payload["token"] = jwt
-			return c.JSON(http.StatusOK, ctx.Payload)
-		}
-	}
-
-	return c.JSON(http.StatusUnauthorized, map[string]interface{}{"status": "Not Authorized"})
-}
-
-func RecoverPassword(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	email := c.Param("email")
-
-	user := model.User{}
-	count := 0
-
-	err := db.Where("LOWER(email) = LOWER(?)", email).Find(&user).Count(&count).Error
-	if err != nil {
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{"status": "Email Not Found"})
-	}
-
-	if count > 0 {
-		expireAt := model.JWTTokenExpirationDate()
-		jwt, dberr := model.IssueJWTTokenForEmail(user.ID, user.Email, expireAt)
-		if dberr != nil {
-			return log.AddDefaultError(c,
-				core.NewServerError(
-					dberr.Error(),
-					map[string]interface{}{
-						"user_id": ctx.User.ID,
-					},
-				),
-			)
-		}
-
-		user.ResetPasswordEmail(jwt)
-	}
-
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "OK"})
-}
-
-func ChangePasswordExternal(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	type customPasswordExternal struct {
-		Token    string `json:"token"`
-		Password string `json:"password"`
-	}
-
-	u := new(customPasswordExternal)
-	if err := c.Bind(&u); err != nil {
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	secretKey := os.Getenv("JWT_KEY_EMAIL")
-	token, err := model.VerifyJWTToken(u.Token, secretKey)
-	if err != nil {
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{"message": "Token invalid"})
-	}
-
-	if err != nil {
-		log.LoggerForParams(c,
-			map[string]interface{}{
-				"user_id": ctx.User.ID,
-				"status":  "Token invalid",
-				"code":    http.StatusBadRequest,
-			},
-		).Info("ChangePasswordExternal: Token inválido")
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{"message": "Token invalid"})
-	}
-
-	claims := token.Claims.(jwt.MapClaims)
-	if token.Valid && claims["iss"] == model.JWT_ISS {
-		email := claims["email"].(string)
-
-		user := model.User{}
-		err := db.Where("email = ?", email).First(&user).Error
-		if err != nil {
-			return log.AddDefaultError(c, core.NewServerError(err.Error()))
-		}
-
-		hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
-		uerr := db.Model(&user).Set("gorm:save_associations", false).UpdateColumn("hashed_password", hashedPassword).Error
-		if uerr != nil {
-			return log.AddDefaultError(c, core.NewServerError(uerr.Error()))
-		}
-	} else {
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{"message": "Token invalid or expired"})
-	}
-
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "OK"})
-}

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

@@ -1,71 +0,0 @@
-package api_test
-
-import (
-	"testing"
-
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSignIn(t *testing.T) {
-	setup()
-	defer teardown()
-	router := router()
-
-	u := map[string]interface{}{
-		"username": "system",
-		"password": "123456",
-	}
-
-	rw, req := core.NewTestPost("POST", "/public/signin", u)
-
-	router.ServeHTTP(rw, req)
-	core.AssertResponseCode(t, rw, 200)
-
-	actualInt := core.JsonToMap(rw.Body.String())
-	actual := actualInt["results"].(map[string]interface{})
-	assert.Equal(t, actual["username"], "system")
-	assert.Equal(t, actual["email"], "system@model.com")
-}
-
-func TestSignInWrong(t *testing.T) {
-	setup()
-	defer teardown()
-	router := router()
-
-	u := map[string]interface{}{
-		"email":    "testuser@model.com",
-		"password": "password123",
-	}
-
-	rw, req := core.NewTestPost("POST", "/public/signin", u)
-
-	router.ServeHTTP(rw, req)
-	core.AssertResponseCode(t, rw, 401)
-}
-
-func TestSignUp(t *testing.T) {
-	setup()
-	defer teardown()
-	router := router()
-
-	u := map[string]interface{}{
-		"name":     "bruno sato",
-		"username": "brunoksato",
-		"email":    "brunosato@model.com",
-		"password": "password",
-		"phone":    "12982575000",
-	}
-
-	rw, req := core.NewTestPost("POST", "/public/signup", u)
-
-	router.ServeHTTP(rw, req)
-	core.AssertResponseCode(t, rw, 201)
-
-	actualInt := core.JsonToMap(rw.Body.String())
-	actual := actualInt["results"].(map[string]interface{})
-	assert.Equal(t, actual["email"], "brunosato@model.com")
-	assert.Equal(t, actual["name"], "bruno sato")
-	assert.Equal(t, actual["username"], "brunoksato")
-	assert.Equal(t, actual["phone"], "12982575000")
-}

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

@@ -1,120 +0,0 @@
-package api
-
-import (
-	"reflect"
-	"strconv"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/brunoksato/golang-boilerplate/model"
-	"github.com/brunoksato/golang-boilerplate/core"
-	log "github.com/brunoksato/golang-boilerplate/log"
-	"github.com/jinzhu/gorm"
-	"github.com/labstack/echo/v4"
-	"github.com/olivere/elastic"
-)
-
-type Context struct {
-	Database      *gorm.DB
-	Elastic       *elastic.Client
-	Logger        *logrus.Entry
-	Payload       map[string]interface{}
-	Request       map[string]interface{}
-	Type          reflect.Type
-	ParentType    reflect.Type
-	User          model.User
-	AppName       string
-	Method        string
-	Path          string
-	Endpoint      string
-	RequestID     string
-	Configuration model.Configuration
-	APIType       core.APIType
-	ModelCtx      *model.ModelCtx
-}
-
-func ServerContext(c echo.Context) *Context {
-	var t reflect.Type
-	var parentType reflect.Type
-	var user model.User
-	var APIType core.APIType
-	var configuration model.Configuration
-
-	if c.Get("User") != nil {
-		user = c.Get("User").(model.User)
-	}
-
-	if c.Get("Type") != nil {
-		t = c.Get("Type").(reflect.Type)
-	}
-
-	if c.Get("ParentType") != nil {
-		parentType = c.Get("ParentType").(reflect.Type)
-	}
-
-	if c.Get("APIType") != nil {
-		APIType = c.Get("APIType").(core.APIType)
-	}
-
-	if c.Get("Configuration") != nil {
-		configuration = c.Get("Configuration").(model.Configuration)
-	}
-
-	return &Context{
-		RequestID:     c.Get("RequestID").(string),
-		Database:      c.Get("Database").(*gorm.DB),
-		Elastic:       c.Get("Elastic").(*elastic.Client),
-		User:          user,
-		Configuration: configuration,
-		Logger:        log.Logger(c),
-		Type:          t,
-		ParentType:    parentType,
-		Payload:       make(map[string]interface{}),
-		Request:       make(map[string]interface{}),
-		APIType:       APIType,
-	}
-}
-
-func ArgonContext(c echo.Context) *model.ModelCtx {
-	ctx := ServerContext(c)
-	if ctx.ModelCtx == nil {
-		c.Logger().Debug("Creating a new ArgonContext.")
-		ctx.ModelCtx = &model.ModelCtx{
-			RequestID:     ctx.RequestID,
-			APIType:       ctx.APIType,
-			Database:      ctx.Database,
-			Configuration: c.Get("Configuration").(model.Configuration),
-			User:          c.Get("User").(model.User),
-			Logger:        log.Logger(c),
-		}
-	}
-
-	return ctx.ModelCtx
-}
-
-func ArgonContextTransaction(c echo.Context, db *gorm.DB) *model.ModelCtx {
-	ctx := ServerContext(c)
-	if ctx.ModelCtx == nil {
-		c.Logger().Debug("Creating a new ArgonContext.")
-		ctx.ModelCtx = &model.ModelCtx{
-			RequestID:     ctx.RequestID,
-			APIType:       ctx.APIType,
-			Database:      db,
-			Configuration: c.Get("Configuration").(model.Configuration),
-			User:          c.Get("User").(model.User),
-			Logger:        log.Logger(c),
-		}
-	}
-
-	ctx.Database = db
-
-	return ctx.ModelCtx
-}
-
-func ActiveUserID(c echo.Context, ctx *Context) uint {
-	userID := ctx.User.ID
-	uid, _ := strconv.Atoi(c.Param("userId"))
-	if uid > 0 {
-		userID = uint(uid)
-	}
-	return userID
-}

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

@@ -1,24 +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 CronJobSample(c echo.Context) error {
-	ctx := ServerContext(c)
-	db := ctx.Database
-
-	tx := db.Begin()
-	if err := tx.Error; err != nil {
-		tx.Rollback()
-		return log.AddDefaultError(c, core.NewServerError(err.Error()))
-	}
-
-	tx.Commit()
-
-	return c.JSON(http.StatusOK, map[string]interface{}{"status": "ok"})
-}

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

@@ -1,86 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/brunoksato/golang-boilerplate/model"
-	"github.com/brunoksato/golang-boilerplate/core"
-	"github.com/jinzhu/gorm"
-)
-
-func OrderByFor(db *gorm.DB, t reflect.Type) *gorm.DB {
-	if model.IsSorter(t) {
-		item := reflect.New(t).Interface()
-		sorter := item.(model.Sorter)
-		return sorter.OrderBy(db)
-	}
-
-	tableName := db.NewScope(reflect.New(t).Interface()).TableName()
-	tableName = fmt.Sprintf("\"%s\".", tableName)
-	order := tableName + "\"id\" ASC"
-
-	_, orderField := model.OrderField(t)
-	if orderField != "" {
-		order = fmt.Sprintf("%s\"%s\" ASC, %s", tableName, orderField, order)
-	}
-
-	return db.Order(order)
-}
-
-func JoinsFor(ctx *Context, db *gorm.DB, parentIsSpecific bool) *gorm.DB {
-	return db.Scopes(core.DefaultPreloads(db, ctx.Type, ctx.APIType, parentIsSpecific))
-}
-
-func ScopesFor(ctx *Context, path string, userID uint, db *gorm.DB) *gorm.DB {
-	parts := strings.Split(path, "/")
-	for i := len(parts) - 1; i >= 0; i-- {
-		part := parts[i]
-		switch part {
-		//change the name of model
-		case "models":
-			db = db.Where("user_id = ?", userID)
-		}
-
-	}
-	return db
-}
-
-func FilterByParentFor(db *gorm.DB, pt, t reflect.Type, parentID uint) *gorm.DB {
-	userType := reflect.TypeOf(model.User{})
-
-	if pt == userType {
-		db = FilterByUserFor(db, pt, t, parentID)
-	} else if pt != nil {
-		parentField := gorm.ToDBName(pt.Name())
-		db = db.Where(parentField+"_id = ?", parentID)
-	} else if model.TypeHasParentField(t) {
-		_, parentField := model.ParentIdField(t)
-		db = db.Where(parentField+" = ?", parentID)
-	}
-
-	return db
-}
-
-func FilterByUserFor(db *gorm.DB, pt, t reflect.Type, userID uint) *gorm.DB {
-	var zeroType reflect.Type
-
-	ptName := ""
-	if pt != zeroType {
-		ptName = pt.Name()
-	}
-
-	switch ptName {
-	case "", "User":
-		switch t.Name() {
-		default:
-			_, userIDField := model.UserIDField(t)
-			if userIDField == "user_id" {
-				db = db.Where("user_id = ?", userID)
-			}
-		}
-	}
-
-	return db
-}