новый

bin/templates/db_lawsuit_status_types.go

@@ -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)
 //

bin/templates/db_lawsuit_status_types_test.go

@@ -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")
+//	}
+//}

bin/templates/lawsuit_status_type.go

@@ -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 операции ------------------------------------------------------------

bin/templates/message_types.go

@@ -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 операции ------------------------------------------------------------

internal/config/config.go

@@ -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
+}

internal/folders/folders.go

@@ -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
+}

internal/folders/folders_test.go

@@ -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()
+}

internal/main.go

@@ -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 {