go/crud_generator
1
0
Fork 0
mirror of https://github.com/ManyakRus/crud_generator.git synced 2025-01-03 01:22:21 +02:00
Code Issues Releases Activity

новый

Browse Source
This commit is contained in:
Nikitin Aleksandr 2023-10-06 16:48:58 +03:00
parent dae94b634c
commit 85115db79f
8 changed files with 551 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
bin/templates/db_message_types.go → bin/templates/db_lawsuit_status_types.go
View File

@ -1,111 +1,133 @@
package object_model
package db_lawsuit_status_types
import (
"context"
"errors"
"fmt"
model "gitlab.aescorp.ru/dsp_dev/claim/common/object_model"
"gitlab.aescorp.ru/dsp_dev/claim/common/object_model/pkg/db/constants"
"gitlab.aescorp.ru/dsp_dev/claim/nikitin/micro"
"gitlab.aescorp.ru/dsp_dev/claim/nikitin/postgres_gorm"
"gorm.io/gorm"
"time"
)
type crud_MessageType struct {
// TableName - имя таблицы в БД Postgres
const TableName string = "lawsuit_status_types"
// Crud_DB - объект для CRUD операций через БД
type Crud_DB struct {
}
// Read - находит запись в БД по ID
func (crud crud_MessageType) read(m *MessageType) error {
func (crud Crud_DB) Read(l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
//log.Trace("start Read() ", TableName, " id: ", id)
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(TIMEOUT_DB_SECONDS))
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err = crud.read_ctx(ctx, m)
err = crud.Read_ctx(ctx, l)
return err
}
// Read_ctx - находит запись в БД по ID
func (crud crud_MessageType) read_ctx(ctx context.Context, m *MessageType) error {
func (crud Crud_DB) Read_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
id := l.ID
db := postgres_gorm.GetConnection()
db.WithContext(ctx)
tx := db.First(m, m.ID)
tx := db.First(l, id)
err = tx.Error
return err
}
// Save - записывает новый или существующий объект в базу данных
func (crud crud_MessageType) save(m *MessageType) error {
err := crud.create_update(m, false)
func (crud Crud_DB) Save(l *model.LawsuitStatusType) error {
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err := crud.Save_ctx(ctx, l)
return err
}
// Save_ctx - записывает новый или существующий объект в базу данных
func (crud crud_MessageType) save_ctx(ctx context.Context, m *MessageType) error {
is_create := !micro.BoolFromInt64(m.ID)
err := crud.create_update_ctx(ctx, m, is_create)
func (crud Crud_DB) Save_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
is_create := !micro.BoolFromInt64(l.ID)
err := crud.create_update_ctx(ctx, l, is_create)
return err
}
// Update - записывает существующий объект в базу данных
func (crud crud_MessageType) update(m *MessageType) error {
err := crud.create_update(m, false)
func (crud Crud_DB) Update(l *model.LawsuitStatusType) error {
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err := crud.Update_ctx(ctx, l)
return err
}
// Update_ctx - записывает существующий объект в базу данных
func (crud crud_MessageType) update_ctx(ctx context.Context, m *MessageType) error {
err := crud.create_update_ctx(ctx, m, false)
func (crud Crud_DB) Update_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
err := crud.create_update_ctx(ctx, l, false)
return err
}
// Create - записывает новый объект в базу данных
func (crud crud_MessageType) create(m *MessageType) error {
err := crud.create_update(m, true)
func (crud Crud_DB) Create(l *model.LawsuitStatusType) error {
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err := crud.Create_ctx(ctx, l)
return err
}
// Create_ctx - записывает новый объект в базу данных
func (crud crud_MessageType) create_ctx(ctx context.Context, m *MessageType) error {
err := crud.create_update_ctx(ctx, m, true)
func (crud Crud_DB) Create_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
err := crud.create_update_ctx(ctx, l, true)
return err
}
// create_update - записывает объект в базу данных
func (crud crud_MessageType) create_update(m *MessageType, is_create bool) error {
func (crud Crud_DB) create_update(l *model.LawsuitStatusType, is_create bool) error {
var err error
//log.Trace("start Save() ", TableName, " id: ", m.ID)
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(TIMEOUT_DB_SECONDS))
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err = crud.create_update_ctx(ctx, m, is_create)
err = crud.create_update_ctx(ctx, l, is_create)
return err
}
// create_update_ctx - записывает объект в базу данных
func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageType, is_create bool) error {
func (crud Crud_DB) create_update_ctx(ctx context.Context, l *model.LawsuitStatusType, is_create bool) error {
var err error
//log.Trace("start Save() ", TableName, " id: ", m.ID)
// проверка ID
if is_create == true {
if m.ID != 0 {
TextError := fmt.Sprint("db.Save() ", m.TableName(), " error: id !=0")
if l.ID != 0 {
TextError := fmt.Sprint("db.Save() ", TableName, " error: id !=0")
//log.Panic(sError)
err = errors.New(TextError)
return err
}
} else if m.ID == 0 {
TextError := fmt.Sprint("db.Save() ", m.TableName(), " error: id =0")
} else if l.ID == 0 {
TextError := fmt.Sprint("db.Save() ", TableName, " error: id =0")
err = errors.New(TextError)
//log.Panic(sError)
return err
@ -117,11 +139,11 @@ func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageTy
//заполним даты
Now := time.Now()
m.ModifiedAt = Now
if m.IsDeleted == true && m.DeletedAt.IsZero() == true {
m.DeletedAt = Now
} else if m.IsDeleted == false && m.DeletedAt.IsZero() == false {
m.DeletedAt = time.Time{}
l.ModifiedAt = Now
if l.IsDeleted == true && l.DeletedAt.IsZero() == true {
l.DeletedAt = Now
} else if l.IsDeleted == false && l.DeletedAt.IsZero() == false {
l.DeletedAt = time.Time{}
}
//колонки с null
@ -130,12 +152,12 @@ func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageTy
var ColumnName string
ColumnName = "DeletedAt"
if m.DeletedAt.IsZero() == true {
if l.DeletedAt.IsZero() == true {
MassOmit = append(MassOmit, ColumnName)
}
ColumnName = "ExtID"
if m.ExtID == 0 {
if l.ExtID == 0 {
MassOmit = append(MassOmit, ColumnName)
}
@ -144,9 +166,9 @@ func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageTy
//запись
if is_create == true {
tx = tx.Create(m)
tx = tx.Create(&l)
} else {
tx = tx.Save(m)
tx = tx.Save(&l)
}
err = tx.Error
if err != nil {
@ -156,11 +178,11 @@ func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageTy
//запишем NULL в пустые колонки
for f := 0; f < len(MassOmit); f++ {
ColumnName := MassOmit[f]
tx = db.First(m).Update(ColumnName, gorm.Expr("NULL"))
tx = db.First(&l).Update(ColumnName, gorm.Expr("NULL"))
err = tx.Error
if err != nil {
TextError := fmt.Sprint("db.Update() ", m.TableName(), " id: ", m.ID, " error: ", err)
TextError := fmt.Sprint("db.Update() ", TableName, " id: ", l.ID, " error: ", err)
err = errors.New(TextError)
return err
//log.Panic(sError)
@ -171,70 +193,74 @@ func (crud crud_MessageType) create_update_ctx(ctx context.Context, m *MessageTy
}
// Delete - записывает is_deleted = true
func (crud crud_MessageType) delete(m *MessageType) error {
func (crud Crud_DB) Delete(l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(TIMEOUT_DB_SECONDS))
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err = crud.delete_ctx(ctx, m)
err = crud.Delete_ctx(ctx, l)
return err
}
// Delete_ctx - записывает is_deleted = true
func (crud crud_MessageType) delete_ctx(ctx context.Context, m *MessageType) error {
func (crud Crud_DB) Delete_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
var m2 *MessageType
m2.ID = m.ID
err = crud.read_ctx(ctx, m2)
l2 := model.LawsuitStatusType{}
l2.ID = l.ID
err = crud.Read_ctx(ctx, &l2)
if err != nil {
return err
}
m.IsDeleted = true
m2.IsDeleted = true
l2.IsDeleted = true
l.IsDeleted = true
err = crud.save_ctx(ctx, m2)
err = crud.Save_ctx(ctx, &l2)
return err
}
// Restore - записывает is_deleted = true
func (crud crud_MessageType) restore(m *MessageType) error {
func (crud Crud_DB) Restore(l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
ctxMain := context.Background()
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(TIMEOUT_DB_SECONDS))
ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
defer ctxCancelFunc()
err = crud.restore_ctx(ctx, m)
err = crud.Restore_ctx(ctx, l)
return err
}
// Restore_ctx - записывает is_deleted = true
func (crud crud_MessageType) restore_ctx(ctx context.Context, m *MessageType) error {
func (crud Crud_DB) Restore_ctx(ctx context.Context, l *model.LawsuitStatusType) error {
//var Otvet model.LawsuitStatusType
var err error
var m2 *MessageType
m2.ID = m.ID
err = crud.read_ctx(ctx, m2)
l2 := model.LawsuitStatusType{}
l2.ID = l.ID
err = crud.Read_ctx(ctx, &l2)
if err != nil {
return err
}
m.IsDeleted = false
m2.IsDeleted = false
l2.IsDeleted = false
l.IsDeleted = false
err = crud.save_ctx(ctx, m2)
err = crud.Save_ctx(ctx, &l2)
return err
}
//// Find_ByExtID - находит запись в БД по ext_id и connection_id
//func Find_ByExtID(ext_id int64, connection_id int64) (MessageType, error) {
// var Otvet MessageType
//func Find_ByExtID(ext_id int64, connection_id int64) (model.LawsuitStatusType, error) {
// var Otvet model.LawsuitStatusType
// var err error
//
// if ext_id <= 0 {
@ -244,17 +270,17 @@ func (crud crud_MessageType) restore_ctx(ctx context.Context, m *MessageType) er
//
// //
// ctxMain := context.Background()
// ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(TIMEOUT_DB_SECONDS))
// ctx, ctxCancelFunc := context.WithTimeout(ctxMain, time.Second*time.Duration(constants.TIMEOUT_DB_SECONDS))
// defer ctxCancelFunc()
//
// Otvet, err = Find_ByExtID_ctx(ctx, ext_id, connection_id)
//
// return Otvet, err
//}
//
//// Find_ByExtID_ctx - находит запись в БД по ext_id и connection_id
//func Find_ByExtID_ctx(ctx context.Context, ext_id int64, connection_id int64) (MessageType, error) {
// var Otvet MessageType
//func Find_ByExtID_ctx(ctx context.Context, ext_id int64, connection_id int64) (model.LawsuitStatusType, error) {
// var Otvet model.LawsuitStatusType
// var err error
// //log.Trace("start Find_ByExtID() ", TableName, " ext_id: ", ext_id)
//

111
bin/templates/db_lawsuit_status_types_test.go Normal file
View File

@ -0,0 +1,111 @@
package db_lawsuit_status_types
import (
model "gitlab.aescorp.ru/dsp_dev/claim/common/object_model"
"gitlab.aescorp.ru/dsp_dev/claim/nikitin/config"
"gitlab.aescorp.ru/dsp_dev/claim/nikitin/postgres_gorm"
"testing"
)
const Postgres_ID_Test = 1
func TestRead(t *testing.T) {
config.LoadEnv()
postgres_gorm.Connect()
defer postgres_gorm.CloseConnection()
crud := Crud_DB{}
Otvet := model.LawsuitStatusType{}
Otvet.ID = Postgres_ID_Test
err := crud.Read(&Otvet)
if err != nil {
t.Error("TestRead() error: ", err)
}
if Otvet.Name == "" {
t.Error(TableName + "_test.TestRead() error name= '' ")
} else {
t.Log(TableName+"_test.TestRead() Otvet: ", Otvet.Name)
}
}
func TestSave(t *testing.T) {
config.LoadEnv()
postgres_gorm.Connect()
defer postgres_gorm.CloseConnection()
crud := Crud_DB{}
Otvet := model.LawsuitStatusType{}
Otvet.ID = Postgres_ID_Test
err := crud.Read(&Otvet)
if err != nil {
t.Error("TestSave() error: ", err)
}
if Otvet.Name == "" {
t.Error(TableName + "_test.TestSave() error name= '' ")
}
err = crud.Save(&Otvet)
if err != nil {
t.Error("TestSave() error: ", err)
}
t.Log(TableName+"_test.TestSave() Otvet: ", Otvet.Name)
}
func TestDelete(t *testing.T) {
config.LoadEnv()
postgres_gorm.Connect()
defer postgres_gorm.CloseConnection()
crud := Crud_DB{}
Otvet := model.LawsuitStatusType{}
Otvet.ID = Postgres_ID_Test
err := crud.Read(&Otvet)
if err != nil {
t.Error("TestDelete() error: ", err)
}
if Otvet.IsDeleted == false {
err = crud.Delete(&Otvet)
if err != nil {
t.Error("TestDelete() error: ", err)
}
err = crud.Restore(&Otvet)
if err != nil {
t.Error("TestDelete() error: ", err)
}
} else {
err = crud.Restore(&Otvet)
if err != nil {
t.Error("TestDelete() error: ", err)
}
err = crud.Delete(&Otvet)
if err != nil {
t.Error("TestDelete() error: ", err)
}
}
}
//func TestFind_ByExtID(t *testing.T) {
// config.LoadEnv()
// postgres_gorm.Connect()
// defer postgres_gorm.CloseConnection()
//
// Otvet, err := Find_ByExtID(1, constants.CONNECTION_ID_TEST)
// if err != nil {
// t.Error("TestFind_ByExtID() error: ", err)
// }
//
// if Otvet.ID == 0 {
// t.Error("TestFind_ByExtID() error: ID =0")
// }
//}

145
bin/templates/lawsuit_status_type.go Normal file
View File

@ -0,0 +1,145 @@
package object_model
import (
"encoding/json"
"github.com/vmihailenco/msgpack/v5"
"reflect"
)
// versionLawsuitStatusType - версия структуры модели, с учётом имен и типов полей
var versionLawsuitStatusType uint32
// crud_LawsuitStatusType - объект контроллер crud операций
var crud_LawsuitStatusType ICrud_LawsuitStatusType
// LawsuitStatusType Статусы дел (справочник).
type LawsuitStatusType struct {
CommonStruct
NameStruct
Code string `json:"code" gorm:"column:code;default:0"`
}
type ICrud_LawsuitStatusType interface {
Read(l *LawsuitStatusType) error
Save(l *LawsuitStatusType) error
Update(l *LawsuitStatusType) error
Create(l *LawsuitStatusType) error
Delete(l *LawsuitStatusType) error
Restore(l *LawsuitStatusType) error
}
// TableName - возвращает имя таблицы в БД, нужен для gorm
func (l LawsuitStatusType) TableName() string {
return "lawsuit_status_types"
}
// NewLawsuitStatusType - возвращает новый объект
func NewLawsuitStatusType() LawsuitStatusType {
return LawsuitStatusType{}
}
// AsLawsuitStatusType - создаёт объект из упакованного объекта в массиве байтов
func AsLawsuitStatusType(b []byte) (LawsuitStatusType, error) {
c := NewLawsuitStatusType()
err := msgpack.Unmarshal(b, &c)
if err != nil {
return NewLawsuitStatusType(), err
}
return c, nil
}
// LawsuitStatusTypeAsBytes - упаковывает объект в массив байтов
func LawsuitStatusTypeAsBytes(l *LawsuitStatusType) ([]byte, error) {
b, err := msgpack.Marshal(l)
if err != nil {
return nil, err
}
return b, nil
}
// GetStructVersion - возвращает версию модели
func (l LawsuitStatusType) GetStructVersion() uint32 {
if versionLawsuitStatusType == 0 {
versionLawsuitStatusType = CalcStructVersion(reflect.TypeOf(l))
}
return versionLawsuitStatusType
}
// GetModelFromJSON - создаёт модель из строки json
func (l *LawsuitStatusType) GetModelFromJSON(sModel string) error {
var err error
var bytes []byte
bytes = []byte(sModel)
err = json.Unmarshal(bytes, l)
return err
}
// GetJSON - возвращает строку json из модели
func (l LawsuitStatusType) GetJSON() (string, error) {
var ReturnVar string
var err error
bytes, err := json.Marshal(l)
if err != nil {
return ReturnVar, err
}
ReturnVar = string(bytes)
return ReturnVar, err
}
//---------------------------- CRUD операции ------------------------------------------------------------
// Read - находит запись в БД по ID, и заполняет в объект
func (l *LawsuitStatusType) Read() error {
err := crud_LawsuitStatusType.Read(l)
return err
}
// Save - записывает объект в БД по ID
func (l *LawsuitStatusType) Save() error {
err := crud_LawsuitStatusType.Save(l)
return err
}
// Update - обновляет объект в БД по ID
func (l *LawsuitStatusType) Update() error {
err := crud_LawsuitStatusType.Update(l)
return err
}
// Create - создаёт объект в БД с новым ID
func (l *LawsuitStatusType) Create() error {
err := crud_LawsuitStatusType.Create(l)
return err
}
// Delete - устанавливает признак пометки удаления в БД
func (l *LawsuitStatusType) Delete() error {
err := crud_LawsuitStatusType.Delete(l)
return err
}
// Restore - снимает признак пометки удаления в БД
func (l *LawsuitStatusType) Restore() error {
err := crud_LawsuitStatusType.Restore(l)
return err
}
// SetCrudInterface - заполняет интерфейс crud: DB, GRPC, NRPC
func (c LawsuitStatusType) SetCrudInterface(crud ICrud_LawsuitStatusType) {
crud_LawsuitStatusType = crud
return
}
//---------------------------- конец CRUD операции ------------------------------------------------------------

131
bin/templates/message_types.go
View File

@ -1,131 +0,0 @@
package object_model
import (
"encoding/json"
"github.com/vmihailenco/msgpack/v5"
"reflect"
)
// versionMessageType - версия структуры модели, с учётом имен и типов полей
var versionMessageType uint32
// MessageType - Типы сообщений
type MessageType struct {
CommonStruct
NameStruct
Code int `json:"code" gorm:"column:code;default:0"`
}
// TableName - возвращает имя таблицы в БД, нужен для gorm
func (m MessageType) TableName() string {
return "message_types"
}
// GetID - возвращает ID объекта
func (m MessageType) GetID() int64 {
return m.ID
}
// NewMessageType - возвращает новый объект
func NewMessageType() MessageType {
return MessageType{}
}
// AsMessageType - создаёт объект из упакованного объекта в массиве байтов
func AsMessageType(b []byte) (MessageType, error) {
c := NewMessageType()
err := msgpack.Unmarshal(b, &c)
if err != nil {
return NewMessageType(), err
}
return c, nil
}
// MessageTypeAsBytes - упаковывает объект в массив байтов
func MessageTypeAsBytes(m *MessageType) ([]byte, error) {
b, err := msgpack.Marshal(m)
if err != nil {
return nil, err
}
return b, nil
}
// GetStructVersion - возвращает версию модели
func (m MessageType) GetStructVersion() uint32 {
if versionMessageType == 0 {
versionMessageType = CalcStructVersion(reflect.TypeOf(m))
}
return versionMessageType
}
// GetModelFromJSON - создаёт модель из строки json
func (m *MessageType) GetModelFromJSON(sModel string) error {
var err error
var bytes []byte
bytes = []byte(sModel)
err = json.Unmarshal(bytes, m)
return err
}
// GetJSON - возвращает строку json из модели
func (m MessageType) GetJSON() (string, error) {
var ReturnVar string
var err error
bytes, err := json.Marshal(m)
if err != nil {
return ReturnVar, err
}
ReturnVar = string(bytes)
return ReturnVar, err
}
//---------------------------- CRUD операции ------------------------------------------------------------
// Read - находит запись в БД по ID, и заполняет в объект
func (m *MessageType) Read() error {
err := m.read()
return err
}
// Save - записывает объект в БД по ID
func (m *MessageType) Save() error {
err := m.save()
return err
}
// Update - обновляет объект в БД по ID
func (m *MessageType) Update() error {
err := m.update()
return err
}
// Create - создаёт объект в БД с новым ID
func (m *MessageType) Create() error {
err := m.create()
return err
}
// Delete - устанавливает признак пометки удаления в БД
func (m *MessageType) Delete() error {
err := m.delete()
return err
}
// Restore - снимает признак пометки удаления в БД
func (m *MessageType) Restore() error {
err := m.restore()
return err
}
//---------------------------- конец CRUD операции ------------------------------------------------------------

31
internal/config/config.go
View File

@ -2,6 +2,7 @@ package config
import (
"os"
"strings"
)
// Settings хранит все нужные переменные окружения
@ -15,6 +16,10 @@ type SettingsINI struct {
TEMPLATE_FILENAME_DB string
TEMPLATE_FILENAME_GRPC string
TEMPLATE_FILENAME_NRPC string
NEED_CRUD bool
NEED_GRPC bool
NEED_NRPC bool
SERVICE_NAME string
}
// FillSettings загружает переменные окружения в структуру из переменных окружения
@ -27,6 +32,17 @@ func FillSettings() {
Settings.TEMPLATE_FILENAME_GRPC = os.Getenv("TEMPLATE_FILENAME_GRPC")
Settings.TEMPLATE_FILENAME_NRPC = os.Getenv("TEMPLATE_FILENAME_NRPC")
sNEED_CRUD := os.Getenv("NEED_CRUD")
Settings.NEED_CRUD = BoolFromString(sNEED_CRUD)
sNEED_GRPC := os.Getenv("NEED_GRPC")
Settings.NEED_GRPC = BoolFromString(sNEED_GRPC)
sNEED_NRPC := os.Getenv("NEED_NRPC")
Settings.NEED_NRPC = BoolFromString(sNEED_NRPC)
Settings.SERVICE_NAME = os.Getenv("SERVICE_NAME")
//
}
@ -48,3 +64,18 @@ func FillFlags() {
}
}
// BoolFromString - возвращает true если строка = true, или =1
func BoolFromString(s string) bool {
Otvet := false
s = strings.TrimLeft(s, " ")
s = strings.TrimRight(s, " ")
s = strings.ToLower(s)
if s == "true" || s == "1" {
Otvet = true
}
return Otvet
}

160
internal/folders/folders.go Normal file
View File

@ -0,0 +1,160 @@
package folders
import (
"errors"
"github.com/ManyakRus/crud_generator/internal/config"
"github.com/ManyakRus/starter/log"
"github.com/ManyakRus/starter/micro"
"os"
)
// CreateFolder - создаёт папку на диске
func CreateFolder(FilenameFull string, FilePermissions uint32) error {
var err error
FileMode1 := os.FileMode(FilePermissions)
if FilePermissions == 0 {
FileMode1 = os.FileMode(0700)
}
if _, err := os.Stat(FilenameFull); errors.Is(err, os.ErrNotExist) {
err := os.Mkdir(FilenameFull, FileMode1)
if err != nil {
return err
}
}
return err
}
// DeleteFolder - создаёт папку на диске
func DeleteFolder(FilenameFull string) error {
var err error
if _, err := os.Stat(FilenameFull); errors.Is(err, os.ErrNotExist) {
return err
}
err = os.RemoveAll(FilenameFull)
if err != nil {
return err
}
return err
}
func CreateAllFolders() {
var err error
dir := micro.ProgramDir()
//
Filename := dir + config.Settings.SERVICE_NAME
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "internal"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "model"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
if config.Settings.NEED_CRUD == true {
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "db"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
}
if config.Settings.NEED_GRPC == true {
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "grpc_server"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "grpc_client"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "grpc_proto"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
}
if config.Settings.NEED_NRPC == true {
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "nrpc"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "nrpc_server"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "nrpc_client"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
//
Filename = dir + config.Settings.SERVICE_NAME + micro.SeparatorFile() + "pkg" + micro.SeparatorFile() + "grpc" + micro.SeparatorFile() + "grpc_proto"
err = CreateFolder(Filename, 0)
if err != nil {
log.Panic("CreateFolder() ", Filename, " error: ", err)
}
log.Info("CreateFolder() ", Filename)
}
//return err
}

13
internal/folders/folders_test.go Normal file
View File

@ -0,0 +1,13 @@
package folders
import (
"github.com/ManyakRus/crud_generator/internal/config"
ConfigMain "github.com/ManyakRus/starter/config"
"testing"
)
func TestCreateAllFolders(t *testing.T) {
ConfigMain.LoadEnv()
config.FillSettings()
CreateAllFolders()
}

3
internal/main.go
View File

@ -4,7 +4,6 @@ import (
"github.com/ManyakRus/crud_generator/internal/config"
"github.com/ManyakRus/crud_generator/internal/constants"
"github.com/ManyakRus/crud_generator/internal/logic"
"github.com/ManyakRus/crud_generator/pkg/graphml"
ConfigMain "github.com/ManyakRus/starter/config"
"github.com/ManyakRus/starter/log"
"github.com/ManyakRus/starter/postgres_gorm"
@ -22,8 +21,6 @@ func StartApp() {
postgres_gorm.StartDB()
postgres_gorm.GetConnection().Logger.LogMode(1)
graphml.StartReadFile()
log.Info("postgres host: ", postgres_gorm.Settings.DB_HOST)
ok := logic.StartFillAll()
if ok == false {