yt-gen-app/lib/templ/tmpl/backend/db/db.tmpl

// This file generated automatic. Do not change this!

package db

import (
	"database/sql"
	"{{.Name}}/db/model"
	"{{.Name}}/lib"
	"log"
	"os"
	"time"

	uuid "github.com/satori/go.uuid"
	"gorm.io/driver/mysql"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	{{ if .DB.SQLite }}"gorm.io/driver/sqlite"{{ end }}
	"gorm.io/gorm/logger"
)

var DB *gorm.DB

func DBConnect() {
	var err error
	var newLogger logger.Interface
	if lib.AppConfig.Env == "dev" {
		newLogger = logger.New(
			log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
			logger.Config{
				SlowThreshold:             time.Second, // Slow SQL threshold
				LogLevel:                  logger.Info, // Log level
				IgnoreRecordNotFoundError: true,        // Ignore ErrRecordNotFound error for logger
				ParameterizedQueries:      true,        // Don't include params in the SQL log
				Colorful:                  true,        // Disable color
			},
		)
	}

	var conf = gorm.Config{
		Logger:                           newLogger,
		PrepareStmt:                      true,
		IgnoreRelationshipsWhenMigrating: true,
		CreateBatchSize:                  1000,
	}
	switch lib.AppConfig.DBInstance {
	case "mysql":
		dsn := lib.AppConfig.DbLogin + ":" + lib.AppConfig.DbPassword + "@tcp(" + lib.AppConfig.DbAddress + ":" + lib.AppConfig.DbPort + ")/" + lib.AppConfig.DbName + "?charset=utf8mb4&parseTime=True&loc=Local"
		DB, err = gorm.Open(mysql.Open(dsn), &conf)
		if err != nil {
			log.Fatal(err)
		}
	case "postgres":
		dsn := "host=" + lib.AppConfig.DbAddress + " user=" + lib.AppConfig.DbLogin + " password=" + lib.AppConfig.DbPassword + " dbname=" + lib.AppConfig.DbName + " port=" + lib.AppConfig.DbPort + " sslmode=disable TimeZone=Europe/Moscow"
		DB, err = gorm.Open(postgres.Open(dsn), &conf)
		if err != nil {
			log.Fatal(err)
		}
	{{ if .DB.SQLite }}
	case "sqlite":
		dsn := lib.AppConfig.DbPath
		DB, err = gorm.Open(sqlite.Open(dsn), &conf)
		if err != nil {
			log.Fatal(err)
		}
	{{ end }}
	default:
		log.Fatal("Server DB not set")
	}

	var sqlDB *sql.DB

	sqlDB, err = DB.DB()
	if err != nil {
		log.Fatal(err)
	}

	// SetMaxIdleConns устанавливает максимальное количество подключений в пуле незанятых подключений.
	sqlDB.SetMaxIdleConns(100)

	// SetMaxOpenConns устанавливает максимальное количество открытых подключений к базе данных.
	sqlDB.SetMaxOpenConns(100)

	// SetConnMaxLifetime устанавливает максимальное время, в течение которого соединение может использоваться повторно.
	sqlDB.SetConnMaxLifetime(time.Hour)

	tx := BeginTransation()

	err = tx.AutoMigrate(
		model.User{},
		model.Role{},
		model.UserRole{},
		{{ range $index, $table := .DB.Tables }}
		model.{{fieldNamePrepare $table.Name }}{},
		{{ end }}
	)

	EndTransaction(tx, err)

	if err != nil {
		log.Fatal(err)
	}

	updateRoles()
	updateUsers()

}

// Получить роль по имени
func GetRoleByName(tx *gorm.DB, name string) (role *model.Role) {
	tx.First(&role, "name = ?", name)
	return role
}

// Получить ID роли по имени
func GetRoleIDByName(tx *gorm.DB, name string) uuid.UUID{
	role:=GetRoleByName(tx,name)
	if role==nil {
		return uuid.Nil
	}
	return role.ID
}

// Обновление ролей
func updateRoles() {
	roles:=[]model.Role{
	{{ range $i, $field := .Roles }}
		{
			Base: model.Base{
				ID: uuid.FromStringOrNil("{{ $field.ID }}"),
			},
			Name: "{{ $field.Name }}",
			Description: &[]string{"{{ $field.Display }}"}[0],
		},
	{{ end }}
	}

	var err error

	tx:=BeginTransation()

	defer func() {
		EndTransaction(tx, err)
	}()

	for _, item := range roles {
		var role model.Role
		if res := tx.First(&role, "id = ?", item.ID); res.RowsAffected == 0 {
			// Новая запись
			if res := tx.Create(&item); res.RowsAffected == 0 {
				panic(err)
			}
			continue
		}
		// Обновление записи
		role.Name = item.Name
		role.Description = item.Description
		if res := tx.Save(&role); res.RowsAffected == 0 {
			if res := tx.Create(&item); res.RowsAffected == 0 {
				panic(err)
			}
		}
	}
}

// Создание и обновление основных пользователей
func updateUsers() {

	var err error

	tx := DB.Begin()

	defer func() {
		EndTransaction(tx, err)
	}()

	users := []model.User{
		{
			Base: model.Base{
				ID: uuid.FromStringOrNil("b76cb731-9d5b-46d0-b8eb-551630cf559c"),
			},
			Login:   "app_admin",
			Surname: "app_admin",
			Name:    "app_admin",
			UserRole: []model.UserRole{
				{
					RoleID: GetRoleIDByName(tx, "APP_ADMIN"),
				},
			},
		},
		{
			Base: model.Base{
				ID: uuid.FromStringOrNil("2bd85923-73ca-4f11-89b0-72e00b3bd4d4"),
			},
			Login:   "sec_admin",
			Surname: "sec_admin",
			Name:    "sec_admin",
			UserRole: []model.UserRole{
				{
					RoleID: GetRoleIDByName(tx, "SEC_ADMIN"),
				},
			},
		},
	}

	for _, item := range users {
		var user model.User
		if res := tx.First(&user, "id = ?", item.ID); res.RowsAffected == 0 {
			// Новая запись
			item.SetPassword(item.Login)
			if res := tx.Create(&item); res.RowsAffected == 0 {
				panic(err)
			}
			continue
		}
	}
}