work with cfg

2024-11-26 18:28:42 +03:00 · 2024-11-26 18:28:42 +03:00 · 9e3136bd41
commit 9e3136bd41
parent 4533cd318b
25 changed files with 297 additions and 432 deletions
--- a/deployments/staging/docker-compose.yaml
+++ b/deployments/staging/docker-compose.yaml
@ -29,13 +29,13 @@ services:
      - KAFKA_BROKERS=10.8.0.6:9092
      - KAFKA_TOPIC_TARIFF=tariffs

-      - AUTH_MICROSERVICE_USER_URL=http://10.8.0.6:59300/user
-      - HUBADMIN_MICROSERVICE_TARIFF_URL=http://10.8.0.6:59303/tariff
-      - CURRENCY_MICROSERVICE_TRANSLATE_URL=http://10.8.0.6:3131/change
+      - AUTH_MICROSERVICE_URL=http://10.8.0.6:59300
+      - HUBADMIN_MICROSERVICE_URL=http://10.8.0.6:59303
+      - CURRENCY_MICROSERVICE_URL=http://10.8.0.6:3131
      - DISCOUNT_MICROSERVICE_GRPC_HOST=10.8.0.6:9001
      - PAYMENT_MICROSERVICE_GRPC_HOST=10.8.0.6:9085
-      - VERIFICATION_MICROSERVICE_USER_URL=http://10.8.0.6:7036/verification
-      - TEMPLATEGEN_MICROSERVICE_URL=http://10.6.0.17/generator/service
+      - VERIFICATION_MICROSERVICE_URL=http://10.8.0.6:7036
+      - TEMPLATEGEN_MICROSERVICE_URL=http://10.6.0.17
      - API_URL=https://api.smtp.bz/v1/smtp/send
      - CODEWORD_MICROSERVICE_GRPC_HOST=10.8.0.6:59665
      - MAIL_SENDER=noreply@mailing.pena.digital
--- a/internal/app/app.go
+++ b/internal/app/app.go
@ -48,7 +48,7 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()

-	clickHouseLogger, err := zaptrashlog.NewCore(ctx, zap.InfoLevel, config.Service.TrashLogHost, build.Version, build.Commit, build.BuildTime)
+	clickHouseLogger, err := zaptrashlog.NewCore(ctx, zap.InfoLevel, config.TrashLogHost, build.Version, build.Commit, build.BuildTime)
 	if err != nil {
 		panic(err)
 	}
@ -57,12 +57,12 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 		return zapcore.NewTee(core, clickHouseLogger)
 	}), zap.AddCallerSkip(2))

-	loggerHlog := hlog.New(loggerForHlog).Module(config.Service.ModuleLogger)
+	loggerHlog := hlog.New(loggerForHlog).Module(config.ModuleLogger)
 	loggerHlog.With(models.AllFields{})
 	loggerHlog.Emit(app.InfoSvcStarted{})

-	if err = kafka.Initialize(ctx, config.Service.Kafka.Brokers, []string{
-		config.Service.Kafka.Tariff.Topic,
+	if err = kafka.Initialize(ctx, config.KafkaBrokers, []string{
+		config.KafkaTopic,
 	}); err != nil {
 		return fmt.Errorf("failed initialize kafka: %w", err)
 	}
@ -76,10 +76,10 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 	}

 	kafkaTariffClient, err := kgo.NewClient(
-		kgo.SeedBrokers(config.Service.Kafka.Brokers...),
+		kgo.SeedBrokers(config.KafkaBrokers...),
 		kgo.ConsumeResetOffset(kgo.NewOffset().AtStart()),
-		kgo.DefaultProduceTopic(config.Service.Kafka.Tariff.Topic),
-		kgo.ConsumeTopics(config.Service.Kafka.Tariff.Topic),
+		kgo.DefaultProduceTopic(config.KafkaTopic),
+		kgo.ConsumeTopics(config.KafkaTopic),
 	)
 	if err != nil {
 		return err
@ -96,7 +96,7 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 	}

 	notificationBot, err := tb.NewBot(tb.Settings{
-		Token:     config.Service.NotificationBotToken,
+		Token:     config.NotificationBotToken,
 		Verbose:   false,
 		ParseMode: tb.ModeHTML,
 		Poller: &tb.LongPoller{
@ -110,17 +110,17 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)

 	clients := initialize.NewClients(initialize.ClientsDeps{
 		Logger:                   logger,
-		AuthURL:                      &config.Service.AuthMicroservice.URL,
-		HubadminURL:                  &config.Service.HubadminMicroservice.URL,
-		CurrencyURL:                  &config.Service.CurrencyMicroservice.URL,
-		DiscountServiceConfiguration: &config.Service.DiscountMicroservice,
-		PaymentServiceConfiguration:  &config.Service.PaymentMicroservice,
-		VerificationURL:              &config.Service.VerificationMicroservice.URL,
-		TemplategenURL:               &config.Service.TemplategenMicroserviceURL.URL,
-		MailClient:                   &config.Service.Mail,
-		CodewordServiceHost:          &config.Service.CodewordMicroservice,
+		AuthURL:                  config.AuthMicroservice,
+		HubadminURL:              config.HubadminMicroservice,
+		CurrencyURL:              config.CurrencyMicroservice,
+		DiscountServiceURL:       config.DiscountMicroservice,
+		PaymentServiceURL:        config.PaymentMicroservice,
+		VerificationURL:          config.VerificationMicroservice,
+		TemplategenURL:           config.TemplategenMicroserviceURL,
+		MailClient:               config.MailClientCfg,
+		CodewordServiceHost:      config.CodewordMicroservice,
 		Notifier:                 notificationBot,
-		NotificationRsPayChannel:     config.Service.NotificationRsPayChannel,
+		NotificationRsPayChannel: config.NotificationRsPayChannel,
 	})

 	repositories := initialize.NewRepositories(initialize.RepositoriesDeps{
@ -132,11 +132,10 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 		Logger:              logger,
 		Repositories:        repositories,
 		Clients:             clients,
-		ConfigurationGRPC:   &config.GRPC,
 		Brokers:             brokers,
 		Notifier:            notificationBot,
-		NotificationChannel: config.Service.NotificationChannel,
-		AdminURL:            config.Service.AdminURL,
+		NotificationChannel: config.NotificationChannel,
+		AdminURL:            config.AdminURL,
 	})

 	rpcControllers := initialize.NewRpcControllers(initialize.RpcControllersDeps{
@ -153,7 +152,7 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 		Logger:       logger,
 		Encrypt:      encrypt,
 		Producer:     brokers.TariffProducer,
-		GRPC:         &config.GRPC,
+		GRPCDomain:   config.GrpcDomen,
 		Repositories: repositories,
 		Clients:      clients,
 		MiddleWare:   middleWare,
@ -163,14 +162,14 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 		Logger:      logger,
 		Hlog:        loggerHlog,
 		Controllers: []server.Controller{httpControllers.CurrencyClientController, httpControllers.HistoryClientController, httpControllers.CartClientController, httpControllers.WalletClientController, httpControllers.AccountClientController},
-		JWTConfig:   &config.Service.JWT,
+		JWTConfig:   &config.JwtCfg,
 	})

 	serverAdminHTTP := server.NewServer(server.ServerConfig{
 		Logger:      logger,
 		Hlog:        loggerHlog,
 		Controllers: []server.Controller{httpControllers.AccountAdminController, httpControllers.CurrencyAdminController, httpControllers.HistoryAdminController},
-		JWTConfig:   &config.Service.JWT,
+		JWTConfig:   &config.JwtCfg,
 	})

 	serverClientHTTP.ListRoutes()
@ -184,20 +183,20 @@ func Run(config *models.Config, logger *zap.Logger, build Build) (appErr error)
 	serverGRPC.Register(rpcControllers)

 	go func() {
-		if err := serverClientHTTP.Start(config.HTTP.ClientHost + ":" + config.HTTP.ClientPort); err != nil {
+		if err := serverClientHTTP.Start(config.ClientHttpHost + ":" + config.ClientHttpPort); err != nil {
 			logger.Error("Server external startup error", zap.Error(err))
 			cancel()
 		}
 	}()

 	go func() {
-		if err := serverAdminHTTP.Start(config.HTTP.AdminHost + ":" + config.HTTP.AdminPort); err != nil {
+		if err := serverAdminHTTP.Start(config.AdminHttpHost + ":" + config.AdminHttpPort); err != nil {
 			logger.Error("Server internal startup error", zap.Error(err))
 			cancel()
 		}
 	}()

-	go serverGRPC.Run(&config.GRPC)
+	go serverGRPC.Run(config.GrpcHost, config.GrpcPort)

 	closer.Add(mongoDB.Client().Disconnect)
 	closer.Add(serverClientHTTP.Shutdown)
--- a/internal/initialize/clients.go
+++ b/internal/initialize/clients.go
@ -1,24 +1,23 @@
 package initialize

 import (
-	"github.com/gofiber/fiber/v2"
-	"go.uber.org/zap"
-	"gopkg.in/tucnak/telebot.v2"
 	"gitea.pena/PenaSide/customer/internal/interface/client"
 	"gitea.pena/PenaSide/customer/internal/models"
+	"go.uber.org/zap"
+	"gopkg.in/tucnak/telebot.v2"
 )

 type ClientsDeps struct {
 	Logger                   *zap.Logger
-	AuthURL                      *models.AuthMicroserviceURL
-	HubadminURL                  *models.HubadminMicroserviceURL
-	CurrencyURL                  *models.CurrencyMicroserviceURL
-	DiscountServiceConfiguration *models.DiscountMicroserviceConfiguration
-	PaymentServiceConfiguration  *models.PaymentMicroserviceConfiguration
-	VerificationURL              *models.VerificationMicroserviceURL
-	TemplategenURL               *models.TemplategenMicroserviceURL
-	MailClient                   *models.MailConfiguration
-	CodewordServiceHost          *models.CodewordMicroserviceConfiguration
+	AuthURL                  string
+	HubadminURL              string
+	CurrencyURL              string
+	DiscountServiceURL       string
+	PaymentServiceURL        string
+	VerificationURL          string
+	TemplategenURL           string
+	MailClient               models.MailClientCfg
+	CodewordServiceHost      string
 	NotificationRsPayChannel int64
 	Notifier                 *telebot.Bot
 }
@ -40,48 +39,36 @@ func NewClients(deps ClientsDeps) *Clients {
 	return &Clients{
 		AuthClient: client.NewAuthClient(client.AuthClientDeps{
 			Logger: deps.Logger,
-			URLs:   deps.AuthURL,
+			URL:    deps.AuthURL,
 		}),
 		HubadminClient: client.NewHubadminClient(client.HubadminClientDeps{
 			Logger: deps.Logger,
-			URLs:   deps.HubadminURL,
+			URL:    deps.HubadminURL,
 		}),
 		CurrencyClient: client.NewCurrencyClient(client.CurrencyClientDeps{
 			Logger: deps.Logger,
-			URLs:   deps.CurrencyURL,
+			URL:    deps.CurrencyURL,
 		}),
 		DiscountClient: client.NewDiscountClient(client.DiscountClientDeps{
 			Logger:              deps.Logger,
-			DiscountServiceHost: deps.DiscountServiceConfiguration.HostGRPC,
+			DiscountServiceHost: deps.DiscountServiceURL,
 		}),
 		PaymentClient: client.NewPaymentClient(client.PaymentClientDeps{
 			Logger:             deps.Logger,
-			PaymentServiceHost: deps.PaymentServiceConfiguration.HostGRPC,
+			PaymentServiceHost: deps.PaymentServiceURL,
 		}),
 		VerificationClient: client.NewVerificationClient(client.VerificationClientDeps{
 			Logger: deps.Logger,
-			URLs:   deps.VerificationURL,
+			URL:    deps.VerificationURL,
 		}),
 		TemplateClient: client.NewTemplateClient(client.TemplateClientDeps{
 			Logger: deps.Logger,
-			URLs:   deps.TemplategenURL,
-		}),
-		MailClient: client.NewMailClient(client.MailClientDeps{
-			Logger: deps.Logger,
-			ApiUrl: deps.MailClient.ApiUrl,
-			Sender: deps.MailClient.Sender,
-			Auth: &models.PlainAuth{
-				Identity: deps.MailClient.Auth.Identity,
-				Username: deps.MailClient.Auth.Username,
-				Password: deps.MailClient.Auth.Password,
-			},
-			ApiKey:      deps.MailClient.ApiKey,
-			FiberClient: fiber.AcquireClient(),
-			MailAddress: deps.MailClient.MailAddress,
+			URL:    deps.TemplategenURL,
 		}),
+		MailClient: client.NewMailClient(deps.MailClient, deps.Logger),
 		CodewordClient: client.NewCodewordClient(client.CodewordClientDeps{
 			Logger:              deps.Logger,
-			CodewordServiceHost: deps.CodewordServiceHost.HostGRPC,
+			CodewordServiceHost: deps.CodewordServiceHost,
 		}),
 		TelegramClient: client.NewTelegramClient(client.TelegramClientDeps{
 			Notifier:           deps.Notifier,
--- a/internal/initialize/clients_test.go
+++ b/internal/initialize/clients_test.go
@ -3,10 +3,9 @@ package initialize_test
 import (
 	"testing"

+	"gitea.pena/PenaSide/customer/internal/initialize"
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/zap"
-	"gitea.pena/PenaSide/customer/internal/initialize"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

 func TestNewClients(t *testing.T) {
@ -16,13 +15,13 @@ func TestNewClients(t *testing.T) {
 		assert.NotPanics(t, func() {
 			clients := initialize.NewClients(initialize.ClientsDeps{
 				Logger:             logger,
-				AuthURL:                      &models.AuthMicroserviceURL{},
-				HubadminURL:                  &models.HubadminMicroserviceURL{},
-				CurrencyURL:                  &models.CurrencyMicroserviceURL{},
-				DiscountServiceConfiguration: &models.DiscountMicroserviceConfiguration{HostGRPC: "host"},
-				PaymentServiceConfiguration:  &models.PaymentMicroserviceConfiguration{HostGRPC: "host"},
-				VerificationURL:              &models.VerificationMicroserviceURL{Verification: ""},
-				TemplategenURL:               &models.TemplategenMicroserviceURL{Templategen: ""},
+				AuthURL:            "",
+				HubadminURL:        "",
+				CurrencyURL:        "",
+				DiscountServiceURL: "",
+				PaymentServiceURL:  "",
+				VerificationURL:    "",
+				TemplategenURL:     "",
 			})

 			assert.NotNil(t, clients)
--- a/internal/initialize/config.go
+++ b/internal/initialize/config.go
@ -3,10 +3,9 @@ package initialize
 import (
 	"time"

-	"github.com/golang-jwt/jwt/v5"
 	"gitea.pena/PenaSide/customer/internal/models"
-	"gitea.pena/PenaSide/customer/internal/utils"
 	"gitea.pena/PenaSide/customer/pkg/env"
+	"github.com/golang-jwt/jwt/v5"
 )

 // TODO: обработать возможность читать конфиги ещё по json
@ -17,11 +16,11 @@ func Configuration(path string) (*models.Config, error) {
 		return nil, err
 	}

-	if err := utils.ValidateConfigurationURLs(&config.Service); err != nil {
-		return nil, err
-	}
+	//if err := utils.ValidateConfigurationURLs(&config.Service); err != nil {
+	//	return nil, err
+	//}

-	iniJWTConfiguration(&config.Service.JWT)
+	iniJWTConfiguration(&config.JwtCfg)

 	return config, nil
 }
--- a/internal/initialize/config_test.go
+++ b/internal/initialize/config_test.go
@ -4,11 +4,11 @@ import (
 	"testing"
 	"time"

+	"gitea.pena/PenaSide/customer/internal/initialize"
+	"gitea.pena/PenaSide/customer/internal/models"
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/stretchr/testify/assert"
 	"penahub.gitlab.yandexcloud.net/backend/penahub_common/mongo"
-	"gitea.pena/PenaSide/customer/internal/initialize"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

 func TestConfiguration(t *testing.T) {
@ -48,61 +48,30 @@ func TestConfiguration(t *testing.T) {
 func setDefaultTestingENV(t *testing.T) *models.Config {
 	t.Helper()

-	defaultAuthURL := models.AuthMicroserviceURL{
-		User: "http://www.auth.ru/user",
-	}
+	defaultAuthURL := "http://www.auth.ru/user"

-	defaultHubAdminURL := models.HubadminMicroserviceURL{
-		Tariff: "http://www.hubadmin.ru/tariff",
-	}
+	defaultHubAdminURL := "http://www.hubadmin.ru/tariff"

-	defaultCurrencyURL := models.CurrencyMicroserviceURL{
-		Translate: "http://www.currency.ru/change",
-	}
+	defaultCurrencyURL := "http://www.currency.ru/change"

 	defaultConfiguration := models.Config{
-		HTTP: models.ConfigurationHTTP{
-			ClientHost: "localhost",
-			ClientPort: "8080",
-			AdminHost:  "localhost",
-			AdminPort:  "8081",
-		},
-		GRPC: models.ConfigurationGRPC{
-			Host:  "localhost",
-			Port:  "8081",
-			Domen: "domen",
-		},
-		Service: models.ServiceConfiguration{
-			AuthMicroservice: models.AuthMicroserviceConfiguration{
-				URL: defaultAuthURL,
-			},
-			Kafka: models.KafkaConfiguration{
-				Tariff:  models.TariffKafkaConfiguration{Topic: "topic"},
-				Brokers: []string{"localhost:8080", "localhost:8081"},
-			},
-			HubadminMicroservice: models.HubadminMicroserviceConfiguration{
-				URL: defaultHubAdminURL,
-			},
-			CurrencyMicroservice: models.CurrencyMicroserviceConfiguration{
-				URL: defaultCurrencyURL,
-			},
-			DiscountMicroservice: models.DiscountMicroserviceConfiguration{
-				HostGRPC: "domen",
-			},
-			PaymentMicroservice: models.PaymentMicroserviceConfiguration{
-				HostGRPC: "domen",
-			},
-			VerificationMicroservice: models.VerificationMicroserviceConfiguration{
-				URL: models.VerificationMicroserviceURL{
-					Verification: "domen",
-				},
-			},
-			TemplategenMicroserviceURL: models.TemplategenMicroserviceConfiguration{
-				URL: models.TemplategenMicroserviceURL{
-					Templategen: "domen",
-				},
-			},
-			JWT: models.JWTConfiguration{
+		ClientHttpHost:             "localhost",
+		ClientHttpPort:             "8080",
+		AdminHttpHost:              "localhost",
+		AdminHttpPort:              "8081",
+		GrpcHost:                   "localhost",
+		GrpcPort:                   "8081",
+		GrpcDomen:                  "domen",
+		AuthMicroservice:           defaultAuthURL,
+		KafkaTopic:                 "topic",
+		KafkaBrokers:               []string{"localhost:8080", "localhost:8081"},
+		HubadminMicroservice:       defaultHubAdminURL,
+		CurrencyMicroservice:       defaultCurrencyURL,
+		DiscountMicroservice:       "domen",
+		PaymentMicroservice:        "domen",
+		VerificationMicroservice:   "domen",
+		TemplategenMicroserviceURL: "domen",
+		JwtCfg: models.JWTConfiguration{
 			PrivateKey: "jwt private key",
 			PublicKey:  "jwt public key",
 			Issuer:     "issuer",
@ -110,7 +79,6 @@ func setDefaultTestingENV(t *testing.T) *models.Config {
 			Algorithm:  *jwt.SigningMethodRS256,
 			ExpiresIn:  15 * time.Minute,
 		},
-		},
 		Database: mongo.Configuration{
 			Host:         "localhost",
 			Port:         "27017",
@ -121,25 +89,25 @@ func setDefaultTestingENV(t *testing.T) *models.Config {
 		},
 	}

-	t.Setenv("GRPC_HOST", defaultConfiguration.GRPC.Host)
-	t.Setenv("GRPC_PORT", defaultConfiguration.GRPC.Port)
-	t.Setenv("GRPC_DOMEN", defaultConfiguration.GRPC.Domen)
+	t.Setenv("GRPC_HOST", defaultConfiguration.GrpcHost)
+	t.Setenv("GRPC_PORT", defaultConfiguration.GrpcPort)
+	t.Setenv("GRPC_DOMEN", defaultConfiguration.GrpcDomen)

-	t.Setenv("JWT_PUBLIC_KEY", defaultConfiguration.Service.JWT.PublicKey)
-	t.Setenv("JWT_PRIVATE_KEY", defaultConfiguration.Service.JWT.PrivateKey)
-	t.Setenv("JWT_ISSUER", defaultConfiguration.Service.JWT.Issuer)
-	t.Setenv("JWT_AUDIENCE", defaultConfiguration.Service.JWT.Audience)
+	t.Setenv("JWT_PUBLIC_KEY", defaultConfiguration.JwtCfg.PublicKey)
+	t.Setenv("JWT_PRIVATE_KEY", defaultConfiguration.JwtCfg.PrivateKey)
+	t.Setenv("JWT_ISSUER", defaultConfiguration.JwtCfg.Issuer)
+	t.Setenv("JWT_AUDIENCE", defaultConfiguration.JwtCfg.Audience)

 	t.Setenv("KAFKA_BROKERS", "localhost:8080,localhost:8081")
-	t.Setenv("KAFKA_TOPIC_TARIFF", defaultConfiguration.Service.Kafka.Tariff.Topic)
+	t.Setenv("KAFKA_TOPIC_TARIFF", defaultConfiguration.KafkaTopic)

-	t.Setenv("AUTH_MICROSERVICE_USER_URL", defaultConfiguration.Service.AuthMicroservice.URL.User)
-	t.Setenv("HUBADMIN_MICROSERVICE_TARIFF_URL", defaultConfiguration.Service.HubadminMicroservice.URL.Tariff)
-	t.Setenv("CURRENCY_MICROSERVICE_TRANSLATE_URL", defaultConfiguration.Service.CurrencyMicroservice.URL.Translate)
-	t.Setenv("DISCOUNT_MICROSERVICE_GRPC_HOST", defaultConfiguration.Service.DiscountMicroservice.HostGRPC)
-	t.Setenv("PAYMENT_MICROSERVICE_GRPC_HOST", defaultConfiguration.Service.PaymentMicroservice.HostGRPC)
-	t.Setenv("VERIFICATION_MICROSERVICE_USER_URL", defaultConfiguration.Service.VerificationMicroservice.URL.Verification)
-	t.Setenv("TEMPLATEGEN_MICROSERVICE_URL", defaultConfiguration.Service.TemplategenMicroserviceURL.URL.Templategen)
+	t.Setenv("AUTH_MICROSERVICE_URL", defaultConfiguration.AuthMicroservice)
+	t.Setenv("HUBADMIN_MICROSERVICE_URL", defaultConfiguration.HubadminMicroservice)
+	t.Setenv("CURRENCY_MICROSERVICE_URL", defaultConfiguration.CurrencyMicroservice)
+	t.Setenv("DISCOUNT_MICROSERVICE_GRPC_HOST", defaultConfiguration.DiscountMicroservice)
+	t.Setenv("PAYMENT_MICROSERVICE_GRPC_HOST", defaultConfiguration.PaymentMicroservice)
+	t.Setenv("VERIFICATION_MICROSERVICE_URL", defaultConfiguration.VerificationMicroservice)
+	t.Setenv("TEMPLATEGEN_MICROSERVICE_URL", defaultConfiguration.TemplategenMicroserviceURL)

 	t.Setenv("MONGO_HOST", defaultConfiguration.Database.Host)
 	t.Setenv("MONGO_PORT", defaultConfiguration.Database.Port)
--- a/internal/initialize/controllers.go
+++ b/internal/initialize/controllers.go
@ -1,9 +1,6 @@
 package initialize

 import (
-	"github.com/themakers/hlog"
-	"go.uber.org/zap"
-	qutils "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/utils"
 	"gitea.pena/PenaSide/customer/internal/interface/broker/tariff"
 	"gitea.pena/PenaSide/customer/internal/interface/controller/grpc/customer"
 	"gitea.pena/PenaSide/customer/internal/interface/controller/grpc/payment"
@ -16,7 +13,9 @@ import (
 	"gitea.pena/PenaSide/customer/internal/interface/controller/http/history_admin"
 	"gitea.pena/PenaSide/customer/internal/interface/controller/http/history_client"
 	"gitea.pena/PenaSide/customer/internal/interface/controller/http/wallet_client"
-	"gitea.pena/PenaSide/customer/internal/models"
+	"github.com/themakers/hlog"
+	"go.uber.org/zap"
+	qutils "penahub.gitlab.yandexcloud.net/backend/quiz/common.git/utils"
 )

 type RpcControllersDeps struct {
@ -49,7 +48,7 @@ func NewRpcControllers(deps RpcControllersDeps) *RpcControllers {
 type HttpControllersDeps struct {
 	Encrypt      *qutils.Encrypt
 	Producer     *tariff.Producer
-	GRPC         *models.ConfigurationGRPC
+	GRPCDomain   string
 	MiddleWare   *http.MiddleWare
 	Logger       *zap.Logger
 	Repositories *Repositories
@ -126,7 +125,7 @@ func NewHttpControllers(deps HttpControllersDeps) *HttpController {
 			MiddleWare:     deps.MiddleWare,
 			AuthClient:     deps.Clients.AuthClient,
 			PaymentClient:  deps.Clients.PaymentClient,
-			GRPC:           deps.GRPC,
+			GRPCDomain:     deps.GRPCDomain,
 			AccountRepo:    deps.Repositories.AccountRepository,
 			CurrencyClient: deps.Clients.CurrencyClient,
 			VerifyClient:   deps.Clients.VerificationClient,
--- a/internal/initialize/controllers_test.go
+++ b/internal/initialize/controllers_test.go
@ -3,11 +3,10 @@ package initialize_test
 import (
 	"testing"

+	"gitea.pena/PenaSide/customer/internal/initialize"
 	"github.com/stretchr/testify/assert"
 	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
 	"go.uber.org/zap"
-	"gitea.pena/PenaSide/customer/internal/initialize"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

 func TestNewControllers(t *testing.T) {
@ -19,13 +18,13 @@ func TestNewControllers(t *testing.T) {
 		assert.NotPanics(t, func() {
 			clients := initialize.NewClients(initialize.ClientsDeps{
 				Logger:             logger,
-				AuthURL:                      &models.AuthMicroserviceURL{},
-				HubadminURL:                  &models.HubadminMicroserviceURL{},
-				CurrencyURL:                  &models.CurrencyMicroserviceURL{},
-				DiscountServiceConfiguration: &models.DiscountMicroserviceConfiguration{HostGRPC: "host"},
-				PaymentServiceConfiguration:  &models.PaymentMicroserviceConfiguration{HostGRPC: "host"},
-				VerificationURL:              &models.VerificationMicroserviceURL{Verification: ""},
-				TemplategenURL:               &models.TemplategenMicroserviceURL{Templategen: ""},
+				AuthURL:            "",
+				HubadminURL:        "",
+				CurrencyURL:        "",
+				DiscountServiceURL: "host",
+				PaymentServiceURL:  "host",
+				VerificationURL:    "",
+				TemplategenURL:     "",
 			})

 			repositories := initialize.NewRepositories(initialize.RepositoriesDeps{
--- a/internal/initialize/services.go
+++ b/internal/initialize/services.go
@ -1,13 +1,12 @@
 package initialize

 import (
-	"go.uber.org/zap"
-	tb "gopkg.in/tucnak/telebot.v2"
-	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/internal/service/broker/tariff"
 	"gitea.pena/PenaSide/customer/internal/service/callback"
 	"gitea.pena/PenaSide/customer/internal/service/history"
 	"gitea.pena/PenaSide/customer/internal/service/wallet"
+	"go.uber.org/zap"
+	tb "gopkg.in/tucnak/telebot.v2"
 )

 type ServicesDeps struct {
@ -15,7 +14,6 @@ type ServicesDeps struct {
 	Repositories        *Repositories
 	Clients             *Clients
 	Brokers             *Brokers
-	ConfigurationGRPC   *models.ConfigurationGRPC
 	Notifier            *tb.Bot
 	NotificationChannel int64
 	AdminURL            string
--- a/internal/initialize/services_test.go
+++ b/internal/initialize/services_test.go
@ -3,12 +3,11 @@ package initialize_test
 import (
 	"testing"

+	"gitea.pena/PenaSide/customer/internal/initialize"
 	"github.com/stretchr/testify/assert"
 	"github.com/twmb/franz-go/pkg/kgo"
 	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
 	"go.uber.org/zap"
-	"gitea.pena/PenaSide/customer/internal/initialize"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

 func TestNewServices(t *testing.T) {
@ -20,13 +19,13 @@ func TestNewServices(t *testing.T) {
 		assert.NotPanics(t, func() {
 			clients := initialize.NewClients(initialize.ClientsDeps{
 				Logger:             logger,
-				AuthURL:                      &models.AuthMicroserviceURL{},
-				HubadminURL:                  &models.HubadminMicroserviceURL{},
-				CurrencyURL:                  &models.CurrencyMicroserviceURL{},
-				DiscountServiceConfiguration: &models.DiscountMicroserviceConfiguration{HostGRPC: "host"},
-				PaymentServiceConfiguration:  &models.PaymentMicroserviceConfiguration{HostGRPC: "host"},
-				VerificationURL:              &models.VerificationMicroserviceURL{Verification: ""},
-				TemplategenURL:               &models.TemplategenMicroserviceURL{Templategen: ""},
+				AuthURL:            "",
+				HubadminURL:        "",
+				CurrencyURL:        "",
+				DiscountServiceURL: "host",
+				PaymentServiceURL:  "host",
+				VerificationURL:    "",
+				TemplategenURL:     "",
 			})

 			brokers := initialize.NewBrokers(initialize.BrokersDeps{
@ -44,7 +43,6 @@ func TestNewServices(t *testing.T) {
 				Clients:      clients,
 				Repositories: repositories,
 				Brokers:      brokers,
-				ConfigurationGRPC: &models.ConfigurationGRPC{Domen: "http://test:8080"},
 			})

 			assert.NotNil(t, services)
--- a/internal/interface/client/auth.go
+++ b/internal/interface/client/auth.go
@ -6,34 +6,34 @@ import (
 	"log"
 	"net/url"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/internal/utils"
 	"gitea.pena/PenaSide/customer/pkg/client"
+	"go.uber.org/zap"
 )

 type AuthClientDeps struct {
 	Logger *zap.Logger
-	URLs   *models.AuthMicroserviceURL
+	URL    string
 }

 type AuthClient struct {
-	urls *models.AuthMicroserviceURL
+	url string
 }

 func NewAuthClient(deps AuthClientDeps) *AuthClient {
-	if deps.URLs == nil {
-		log.Panicln("urls is nil on <NewAuthClient>")
+	if deps.URL == "" {
+		log.Panicln("url is nil on <NewAuthClient>")
 	}

 	return &AuthClient{
-		urls: deps.URLs,
+		url: deps.URL,
 	}
 }

 func (receiver *AuthClient) GetUser(ctx context.Context, userID string) (*models.User, errors.Error) {
-	userURL, err := url.JoinPath(receiver.urls.User, userID)
+	userURL, err := url.JoinPath(fmt.Sprintf("%s/user", receiver.url), userID)
 	if err != nil {
 		return nil, errors.New(
 			fmt.Errorf("failed to join path on <GetUser> of <AuthClient>: %w", err),
--- a/internal/interface/client/currency.go
+++ b/internal/interface/client/currency.go
@ -6,21 +6,21 @@ import (
 	"log"
 	"strconv"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/internal/utils"
 	"gitea.pena/PenaSide/customer/pkg/client"
+	"go.uber.org/zap"
 )

 type CurrencyClientDeps struct {
 	Logger *zap.Logger
-	URLs   *models.CurrencyMicroserviceURL
+	URL    string
 }

 type CurrencyClient struct {
 	logger *zap.Logger
-	urls   *models.CurrencyMicroserviceURL
+	url    string
 }

 func NewCurrencyClient(deps CurrencyClientDeps) *CurrencyClient {
@ -28,19 +28,19 @@ func NewCurrencyClient(deps CurrencyClientDeps) *CurrencyClient {
 		log.Panicln("logger is nil on <NewCurrencyClient>")
 	}

-	if deps.URLs == nil {
+	if deps.URL == "" {
 		log.Panicln("urls is nil on <NewCurrencyClient>")
 	}

 	return &CurrencyClient{
 		logger: deps.Logger,
-		urls:   deps.URLs,
+		url:    deps.URL,
 	}
 }

 func (receiver *CurrencyClient) Translate(ctx context.Context, request *models.TranslateCurrency) (int64, errors.Error) {
 	response, err := client.Get[models.CurrencyClientResponse[int64], models.CurrencyClientResponse[string]](ctx, &client.RequestSettings{
-		URL:     receiver.urls.Translate,
+		URL:     fmt.Sprintf("%s/change", receiver.url),
 		Headers: map[string]string{"Content-Type": "application/json"},
 		QueryParams: map[string]string{
 			"currencyFrom": request.From,
--- a/internal/interface/client/hubadmin.go
+++ b/internal/interface/client/hubadmin.go
@ -6,21 +6,21 @@ import (
 	"log"
 	"net/url"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/internal/utils"
 	"gitea.pena/PenaSide/customer/pkg/client"
+	"go.uber.org/zap"
 )

 type HubadminClientDeps struct {
 	Logger *zap.Logger
-	URLs   *models.HubadminMicroserviceURL
+	URL    string
 }

 type HubadminClient struct {
 	logger *zap.Logger
-	urls   *models.HubadminMicroserviceURL
+	url    string
 }

 func NewHubadminClient(deps HubadminClientDeps) *HubadminClient {
@ -28,18 +28,18 @@ func NewHubadminClient(deps HubadminClientDeps) *HubadminClient {
 		log.Panicln("logger is nil on <NewHubadminClient>")
 	}

-	if deps.URLs == nil {
+	if deps.URL == "" {
 		log.Panicln("urls is nil on <NewHubadminClient>")
 	}

 	return &HubadminClient{
 		logger: deps.Logger,
-		urls:   deps.URLs,
+		url:    deps.URL,
 	}
 }

 func (receiver *HubadminClient) GetTariff(ctx context.Context, accessToken string, tariffID string) (*models.Tariff, errors.Error) {
-	tariffURL, err := url.JoinPath(receiver.urls.Tariff, tariffID)
+	tariffURL, err := url.JoinPath(fmt.Sprintf("%s/tariff", receiver.url), tariffID)
 	if err != nil {
 		return nil, errors.New(fmt.Errorf("failed to join path on <GetTariff> of <HubadminClient>: %w", err), errors.ErrInternalError)
 	}
--- a/internal/interface/client/mail.go
+++ b/internal/interface/client/mail.go
@ -3,33 +3,35 @@ package client
 import (
 	"bytes"
 	"fmt"
+	"gitea.pena/PenaSide/customer/internal/errors"
+	"gitea.pena/PenaSide/customer/internal/models"
 	"github.com/gofiber/fiber/v2"
 	"go.uber.org/zap"
 	"mime/multipart"
-	"gitea.pena/PenaSide/customer/internal/errors"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

-type MailClientDeps struct {
-	ApiUrl      string
-	Sender      string
-	Auth        *models.PlainAuth
-	ApiKey      string
-	FiberClient *fiber.Client
-	Logger      *zap.Logger
-	MailAddress string
-}
-
 type MailClient struct {
-	deps MailClientDeps
+	apiUrl      string
+	sender      string
+	auth        *models.PlainAuth
+	apiKey      string
+	fiberClient *fiber.Client
+	logger      *zap.Logger
+	mailAddress string
 }

-func NewMailClient(deps MailClientDeps) *MailClient {
+func NewMailClient(deps models.MailClientCfg, logger *zap.Logger) *MailClient {
 	if deps.FiberClient == nil {
 		deps.FiberClient = fiber.AcquireClient()
 	}
 	return &MailClient{
-		deps: deps,
+		apiUrl:      deps.ApiUrl,
+		sender:      deps.Sender,
+		auth:        deps.Auth,
+		apiKey:      deps.ApiKey,
+		fiberClient: deps.FiberClient,
+		logger:      logger,
+		mailAddress: deps.MailAddress,
 	}
 }

@ -47,36 +49,36 @@ func (receiver *MailClient) SendMessage(userEmail string, verification *models.V
 	defer writer.Close()

 	fields := map[string]string{
-		"from":    receiver.deps.Sender,
-		"to":      receiver.deps.MailAddress,
+		"from":    receiver.sender,
+		"to":      receiver.mailAddress,
 		"subject": "Новая заявка на оплату через Р/С",
 		"html":    body,
 	}

 	for key, value := range fields {
 		if err := writer.WriteField(key, value); err != nil {
-			return handleError(receiver.deps.Logger, "Error writing form field", err)
+			return handleError(receiver.logger, "Error writing form field", err)
 		}
 	}

 	if err := writer.Close(); err != nil {
-		return handleError(receiver.deps.Logger, "Error closing form writer", err)
+		return handleError(receiver.logger, "Error closing form writer", err)
 	}

-	fmt.Println("SEEEEEND", receiver.deps.ApiUrl)
-	req := receiver.deps.FiberClient.Post(receiver.deps.ApiUrl).Body(form.Bytes()).ContentType(writer.FormDataContentType())
-	if receiver.deps.ApiKey != "" {
-		req.Set("Authorization", receiver.deps.ApiKey)
+	fmt.Println("SEEEEEND", receiver.apiUrl)
+	req := receiver.fiberClient.Post(receiver.apiUrl).Body(form.Bytes()).ContentType(writer.FormDataContentType())
+	if receiver.apiKey != "" {
+		req.Set("Authorization", receiver.apiKey)
 	}

 	statusCode, _, errs := req.Bytes()
 	if errs != nil {
-		return handleError(receiver.deps.Logger, "Error sending request", errs[0])
+		return handleError(receiver.logger, "Error sending request", errs[0])
 	}

 	if statusCode != fiber.StatusOK {
 		err := fmt.Errorf("the SMTP service returned an error: %d", statusCode)
-		return handleError(receiver.deps.Logger, "Error sending email", err)
+		return handleError(receiver.logger, "Error sending email", err)
 	}

 	return nil
--- a/internal/interface/client/templategen.go
+++ b/internal/interface/client/templategen.go
@ -4,23 +4,24 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"log"
 	"mime/multipart"
 	"net/http"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
+	"go.uber.org/zap"
 )

 type TemplateClientDeps struct {
 	Logger *zap.Logger
-	URLs   *models.TemplategenMicroserviceURL
+	URL    string
 }

 type TemplateClient struct {
 	logger *zap.Logger
-	urls   *models.TemplategenMicroserviceURL
+	url    string
 }

 func NewTemplateClient(deps TemplateClientDeps) *TemplateClient {
@ -28,18 +29,18 @@ func NewTemplateClient(deps TemplateClientDeps) *TemplateClient {
 		log.Panicln("logger is nil on <NewTemplateClient>")
 	}

-	if deps.URLs == nil {
+	if deps.URL == "" {
 		log.Panicln("urls is nil on <NewTemplateClient>")
 	}

 	return &TemplateClient{
 		logger: deps.Logger,
-		urls:   deps.URLs,
+		url:    deps.URL,
 	}
 }

 func (receiver *TemplateClient) SendData(ctx context.Context, data models.RespGeneratorService, fileContents []byte, email string) errors.Error {
-	tmplURL := receiver.urls.Templategen
+	tmplURL := fmt.Sprintf("%s/generator/service", receiver.url)

 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
--- a/internal/interface/client/verification.go
+++ b/internal/interface/client/verification.go
@ -6,20 +6,20 @@ import (
 	"log"
 	"net/url"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/pkg/client"
+	"go.uber.org/zap"
 )

 type VerificationClientDeps struct {
 	Logger *zap.Logger
-	URLs   *models.VerificationMicroserviceURL
+	URL    string
 }

 type VerificationClient struct {
 	logger *zap.Logger
-	urls   *models.VerificationMicroserviceURL
+	url    string
 }

 func NewVerificationClient(deps VerificationClientDeps) *VerificationClient {
@ -27,18 +27,18 @@ func NewVerificationClient(deps VerificationClientDeps) *VerificationClient {
 		log.Panicln("logger is nil on <NewVerificationClient>")
 	}

-	if deps.URLs == nil {
+	if deps.URL == "" {
 		log.Panicln("urls is nil on <NewVerificationClient>")
 	}

 	return &VerificationClient{
 		logger: deps.Logger,
-		urls:   deps.URLs,
+		url:    deps.URL,
 	}
 }

 func (receiver *VerificationClient) GetVerification(ctx context.Context, token, userID string) (*models.Verification, errors.Error) {
-	verifURL, err := url.JoinPath(receiver.urls.Verification, userID)
+	verifURL, err := url.JoinPath(fmt.Sprintf("%s/verification", receiver.url), userID)
 	if err != nil {
 		return nil, errors.New(
 			fmt.Errorf("failed to join path on <GetVerification> of <VerificationClient>: %w", err),
--- a/internal/interface/controller/http/wallet_client/controllers.go
+++ b/internal/interface/controller/http/wallet_client/controllers.go
@ -2,10 +2,7 @@ package wallet_client

 import (
 	"context"
-	"github.com/gofiber/fiber/v2"
-	"go.uber.org/zap"
 	"fmt"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/log_mw"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/interface/client"
 	"gitea.pena/PenaSide/customer/internal/interface/controller/http"
@ -14,13 +11,16 @@ import (
 	"gitea.pena/PenaSide/customer/internal/proto/treasurer"
 	"gitea.pena/PenaSide/customer/internal/utils"
 	"gitea.pena/PenaSide/customer/pkg/validate"
+	"github.com/gofiber/fiber/v2"
+	"go.uber.org/zap"
+	"penahub.gitlab.yandexcloud.net/backend/penahub_common/log_mw"
 )

 type Deps struct {
 	MiddleWare     *http.MiddleWare
 	AuthClient     *client.AuthClient
 	PaymentClient  *client.PaymentClient
-	GRPC           *models.ConfigurationGRPC
+	GRPCDomain     string
 	AccountRepo    *repository.AccountRepository
 	CurrencyClient *client.CurrencyClient
 	VerifyClient   *client.VerificationClient
@ -33,7 +33,7 @@ type WalletController struct {
 	middleWare     *http.MiddleWare
 	authClient     *client.AuthClient
 	paymentClient  *client.PaymentClient
-	grpc           *models.ConfigurationGRPC
+	grpcDomain     string
 	accountRepo    *repository.AccountRepository
 	currencyClient *client.CurrencyClient
 	verifyClient   *client.VerificationClient
@ -47,7 +47,7 @@ func NewWalletController(deps Deps) *WalletController {
 		middleWare:     deps.MiddleWare,
 		authClient:     deps.AuthClient,
 		paymentClient:  deps.PaymentClient,
-		grpc:           deps.GRPC,
+		grpcDomain:     deps.GRPCDomain,
 		accountRepo:    deps.AccountRepo,
 		currencyClient: deps.CurrencyClient,
 		verifyClient:   deps.VerifyClient,
@ -148,7 +148,7 @@ func (receiver *WalletController) GetPaymentLinkBankCard(ctx context.Context, re
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ". " + account.Name.FirstName + " " + account.Name.Secondname,
@ -178,7 +178,7 @@ func (receiver *WalletController) GetPaymentLinkYooMoney(ctx context.Context, re
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ", " + account.Name.FirstName + " " + account.Name.Secondname,
@ -208,7 +208,7 @@ func (receiver *WalletController) GetPaymentLinkSberPay(ctx context.Context, req
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ", " + account.Name.FirstName + " " + account.Name.Secondname,
@ -238,7 +238,7 @@ func (receiver *WalletController) GetPaymentLinkTinkoff(ctx context.Context, req
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ", " + account.Name.FirstName + " " + account.Name.Secondname,
@ -268,7 +268,7 @@ func (receiver *WalletController) GetPaymentLinkSBP(ctx context.Context, request
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ", " + account.Name.FirstName + " " + account.Name.Secondname,
@ -298,7 +298,7 @@ func (receiver *WalletController) GetPaymentLinkB2B(ctx context.Context, request
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.grpc.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 			Customer: &treasurer.Customer{
 				FullName: account.Name.Orgname + ", " + account.Name.FirstName + " " + account.Name.Secondname,
--- a/internal/models/config.go
+++ b/internal/models/config.go
@ -1,61 +1,56 @@
 package models

 import (
-	"time"
-
+	"gitea.pena/PenaSide/common/encrypt"
+	"github.com/gofiber/fiber/v2"
 	"github.com/golang-jwt/jwt/v5"
 	"penahub.gitlab.yandexcloud.net/backend/penahub_common/mongo"
+	"time"
 )

 type Config struct {
-	HTTP     ConfigurationHTTP
-	GRPC     ConfigurationGRPC
-	Service  ServiceConfiguration
-	Database mongo.Configuration
-}
-
-type ConfigurationHTTP struct {
-	ClientHost string `env:"CLIENT_HTTP_HOST,default=localhost"`
-	ClientPort string `env:"CLIENT_HTTP_PORT,default=8080"`
-	AdminHost  string `env:"ADMIN_HTTP_HOST,default=localhost"`
-	AdminPort  string `env:"ADMIN_HTTP_PORT,default=8081"`
-}
-
-type ConfigurationGRPC struct {
-	Host  string `env:"GRPC_HOST,default=localhost"`
-	Port  string `env:"GRPC_PORT,default=8081"`
-	Domen string `env:"GRPC_DOMEN,default=https://domen.ru"`
-}
-
-type ServiceConfiguration struct {
-	AuthMicroservice           AuthMicroserviceConfiguration
-	HubadminMicroservice       HubadminMicroserviceConfiguration
-	CurrencyMicroservice       CurrencyMicroserviceConfiguration
-	DiscountMicroservice       DiscountMicroserviceConfiguration
-	CodewordMicroservice       CodewordMicroserviceConfiguration
-	PaymentMicroservice        PaymentMicroserviceConfiguration
-	VerificationMicroservice   VerificationMicroserviceConfiguration
-	TemplategenMicroserviceURL TemplategenMicroserviceConfiguration
-	JWT                        JWTConfiguration
-	Kafka                      KafkaConfiguration
-	Mail                       MailConfiguration
+	ClientHttpHost             string   `env:"CLIENT_HTTP_HOST,default=localhost"`
+	ClientHttpPort             string   `env:"CLIENT_HTTP_PORT,default=8080"`
+	AdminHttpHost              string   `env:"ADMIN_HTTP_HOST,default=localhost"`
+	AdminHttpPort              string   `env:"ADMIN_HTTP_PORT,default=8081"`
+	GrpcHost                   string   `env:"GRPC_HOST,default=localhost"`
+	GrpcPort                   string   `env:"GRPC_PORT,default=8081"`
+	GrpcDomen                  string   `env:"GRPC_DOMEN,default=https://domen.ru"`
+	AuthMicroservice           string   `env:"AUTH_MICROSERVICE_URL,required"`     // http://10.8.0.6:59300/user
+	HubadminMicroservice       string   `env:"HUBADMIN_MICROSERVICE_URL,required"` // http://10.8.0.6:59303/tariff
+	CurrencyMicroservice       string   `env:"CURRENCY_MICROSERVICE_URL,required"` // http://10.8.0.6:3131/change
+	DiscountMicroservice       string   `env:"DISCOUNT_MICROSERVICE_GRPC_HOST,required"`
+	CodewordMicroservice       string   `env:"CODEWORD_MICROSERVICE_GRPC_HOST,required"`
+	PaymentMicroservice        string   `env:"PAYMENT_MICROSERVICE_GRPC_HOST,required"`
+	VerificationMicroservice   string   `env:"VERIFICATION_MICROSERVICE_URL,required"` // http://10.8.0.6:7036/verification
+	TemplategenMicroserviceURL string   `env:"TEMPLATEGEN_MICROSERVICE_URL,required"`  // http://10.6.0.17/generator/service
+	KafkaTopic                 string   `json:"topic" env:"KAFKA_TOPIC_TARIFF,required"`
+	KafkaBrokers               []string `json:"brokers" env:"KAFKA_BROKERS,required"`
 	TrashLogHost               string   `env:"TRASH_LOG_HOST"`
-	PubKey                     string `env:"PUBLIC_KEY"`
-	PrivKey                    string `env:"PRIVATE_KEY"`
 	ModuleLogger               string   `env:"MODULE_LOGGER"`
 	NotificationBotToken       string   `env:"NOTIFICATION_BOT_TOKEN"`
 	NotificationChannel        int64    `env:"NOTIFICATION_CHANNEL"`
 	AdminURL                   string   `env:"ADMIN_FRONT_URL"`
 	NotificationRsPayChannel   int64    `env:"NOTIFICATION_RS_PAY_CHANNEL"`
+	EncryptCommon              encrypt.Encrypt
+	JwtCfg                     JWTConfiguration
+	MailClientCfg              MailClientCfg
+	Database                   mongo.Configuration
 }

-type KafkaConfiguration struct {
-	Tariff  TariffKafkaConfiguration `json:"tariff"`
-	Brokers []string                 `json:"brokers" env:"KAFKA_BROKERS,required"`
+type MailClientCfg struct {
+	ApiUrl      string `env:"API_URL,required"`
+	Sender      string `env:"MAIL_SENDER,required"`
+	Auth        *PlainAuth
+	ApiKey      string `env:"MAIL_API_KEY,required"`
+	FiberClient *fiber.Client
+	MailAddress string `env:"MAIL_ADDRESS,required"`
 }

-type TariffKafkaConfiguration struct {
-	Topic string `json:"topic" env:"KAFKA_TOPIC_TARIFF,required"`
+type PlainAuth struct {
+	Identity string `env:"MAIL_AUTH_IDENTITY"`
+	Username string `env:"MAIL_AUTH_USERNAME,required"`
+	Password string `env:"MAIL_AUTH_PASSWORD,required"`
 }

 type JWTConfiguration struct {
@ -67,70 +62,4 @@ type JWTConfiguration struct {
 	ExpiresIn  time.Duration
 }

-type AuthMicroserviceConfiguration struct {
-	URL AuthMicroserviceURL
-}
-
-type HubadminMicroserviceConfiguration struct {
-	URL HubadminMicroserviceURL
-}
-
-type CurrencyMicroserviceConfiguration struct {
-	URL CurrencyMicroserviceURL
-}
-
-type VerificationMicroserviceConfiguration struct {
-	URL VerificationMicroserviceURL
-}
-
-type TemplategenMicroserviceConfiguration struct {
-	URL TemplategenMicroserviceURL
-}
-
-type CodewordMicroserviceConfiguration struct {
-	HostGRPC string `env:"CODEWORD_MICROSERVICE_GRPC_HOST,required"`
-}
-
-type PaymentMicroserviceConfiguration struct {
-	HostGRPC string `env:"PAYMENT_MICROSERVICE_GRPC_HOST,required"`
-}
-
-type DiscountMicroserviceConfiguration struct {
-	HostGRPC string `env:"DISCOUNT_MICROSERVICE_GRPC_HOST,required"`
-}
-
-type AuthMicroserviceURL struct {
-	User string `env:"AUTH_MICROSERVICE_USER_URL,required"`
-}
-
-type HubadminMicroserviceURL struct {
-	Tariff string `env:"HUBADMIN_MICROSERVICE_TARIFF_URL,required"`
-}
-
-type CurrencyMicroserviceURL struct {
-	Translate string `env:"CURRENCY_MICROSERVICE_TRANSLATE_URL,required"`
-}
-
-type VerificationMicroserviceURL struct {
-	Verification string `env:"VERIFICATION_MICROSERVICE_USER_URL,required"`
-}
-
-type TemplategenMicroserviceURL struct {
-	Templategen string `env:"TEMPLATEGEN_MICROSERVICE_URL,required"`
-}
-
-type MailConfiguration struct {
-	ApiUrl      string `env:"API_URL,required"`
-	Sender      string `env:"MAIL_SENDER,required"`
-	Auth        PlainAuth
-	ApiKey      string `env:"MAIL_API_KEY,required"`
-	MailAddress string `env:"MAIL_ADDRESS,required"`
-}
-
-type PlainAuth struct {
-	Identity string `env:"MAIL_AUTH_IDENTITY"`
-	Username string `env:"MAIL_AUTH_USERNAME,required"`
-	Password string `env:"MAIL_AUTH_PASSWORD,required"`
-}
-
 const mongoVersion uint32 = 1
--- a/internal/server/grpc.go
+++ b/internal/server/grpc.go
@ -6,16 +6,15 @@ import (
 	"net"
 	"time"

+	"gitea.pena/PenaSide/customer/internal/errors"
+	"gitea.pena/PenaSide/customer/internal/initialize"
+	"gitea.pena/PenaSide/customer/internal/proto/customer"
+	"gitea.pena/PenaSide/customer/internal/proto/payment_callback"
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpc_zap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
 	grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
-	"gitea.pena/PenaSide/customer/internal/errors"
-	"gitea.pena/PenaSide/customer/internal/initialize"
-	"gitea.pena/PenaSide/customer/internal/models"
-	"gitea.pena/PenaSide/customer/internal/proto/customer"
-	"gitea.pena/PenaSide/customer/internal/proto/payment_callback"
 )

 type DepsGRPC struct {
@ -48,8 +47,8 @@ func NewGRPC(deps DepsGRPC) (*GRPC, errors.Error) {
 	}, nil
 }

-func (receiver *GRPC) Run(config *models.ConfigurationGRPC) {
-	connectionString := fmt.Sprintf("%s:%s", config.Host, config.Port)
+func (receiver *GRPC) Run(host, port string) {
+	connectionString := fmt.Sprintf("%s:%s", host, port)

 	receiver.logger.Info("Starting GRPC Server", zap.String("host", connectionString))

--- a/internal/service/payment/payment.go
+++ b/internal/service/payment/payment.go
@ -4,10 +4,10 @@ import (
 	"context"
 	"log"

-	"go.uber.org/zap"
 	"gitea.pena/PenaSide/customer/internal/errors"
 	"gitea.pena/PenaSide/customer/internal/models"
 	"gitea.pena/PenaSide/customer/internal/proto/treasurer"
+	"go.uber.org/zap"
 )

 type paymentClient interface {
@ -24,14 +24,14 @@ type authClient interface {

 type Deps struct {
 	Logger        *zap.Logger
-	ConfigurationGRPC *models.ConfigurationGRPC
+	GRPCDomain    string
 	PaymentClient paymentClient
 	AuthClient    authClient
 }

 type Service struct {
 	logger        *zap.Logger
-	configurationGRPC *models.ConfigurationGRPC
+	grpcDomain    string
 	paymentClient paymentClient
 	authClient    authClient
 }
@ -41,7 +41,7 @@ func New(deps Deps) *Service {
 		log.Panicln("logger is nil on <New (payment service)>")
 	}

-	if deps.ConfigurationGRPC == nil {
+	if deps.GRPCDomain == "" {
 		log.Panicln("ConfigurationGRPC is nil on <New (payment service)>")
 	}

@ -57,7 +57,7 @@ func New(deps Deps) *Service {
 		logger:        deps.Logger,
 		paymentClient: deps.PaymentClient,
 		authClient:    deps.AuthClient,
-		configurationGRPC: deps.ConfigurationGRPC,
+		grpcDomain:    deps.GRPCDomain,
 	}
 }

@ -92,7 +92,7 @@ func (receiver *Service) GetPaymentLinkBankCard(ctx context.Context, request *mo
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 		},
 	})
@ -111,7 +111,7 @@ func (receiver *Service) GetPaymentLinkYooMoney(ctx context.Context, request *mo
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 		},
 	})
@ -130,7 +130,7 @@ func (receiver *Service) GetPaymentLinkSberPay(ctx context.Context, request *mod
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 		},
 	})
@ -149,7 +149,7 @@ func (receiver *Service) GetPaymentLinkTinkoff(ctx context.Context, request *mod
 			Amount:           request.Body.Amount,
 			UserID:           request.UserID,
 			ClientIP:         request.ClientIP,
-			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},
+			CallbackHostGRPC: []string{receiver.grpcDomain},
 			ReturnURL:        request.Body.ReturnURL,
 		},
 	})
--- a/internal/utils/jwt.go
+++ b/internal/utils/jwt.go
@ -3,10 +3,10 @@ package utils
 import (
 	"errors"
 	"fmt"
+	"gitea.pena/PenaSide/customer/internal/models"
 	"time"

 	"github.com/golang-jwt/jwt/v5"
-	"gitea.pena/PenaSide/customer/internal/models"
 )

 type JWT struct {
--- a/internal/utils/validate_configuration_urls.go
+++ b/internal/utils/validate_configuration_urls.go
@ -1,20 +1,13 @@
 package utils

-import (
-	"fmt"
-
-	"gitea.pena/PenaSide/customer/internal/models"
-	"gitea.pena/PenaSide/customer/pkg/validate"
-)
-
-func ValidateConfigurationURLs(config *models.ServiceConfiguration) error {
-	return validateAuthMicroserviceURLs(&config.AuthMicroservice.URL)
-}
-
-func validateAuthMicroserviceURLs(urls *models.AuthMicroserviceURL) error {
-	if !validate.URL(urls.User) {
-		return fmt.Errorf("invalid auth user url: %s", urls.User)
-	}
-
-	return nil
-}
+//func ValidateConfigurationURLs(config *models.ServiceConfiguration) error {
+//	return validateAuthMicroserviceURLs(&config.AuthMicroservice.URL)
+//}
+//
+//func validateAuthMicroserviceURLs(urls *models.AuthMicroserviceURL) error {
+//	if !validate.URL(urls.User) {
+//		return fmt.Errorf("invalid auth user url: %s", urls.User)
+//	}
+//
+//	return nil
+//}
--- a/scripts/data_to_clickhouse/main.go
+++ b/scripts/data_to_clickhouse/main.go
@ -49,9 +49,7 @@ func main() {

 	authClient := client.NewAuthClient(client.AuthClientDeps{
 		Logger: logger,
-		URLs: &models.AuthMicroserviceURL{
-			User: AuthServiceUrl,
-		},
+		URL:    AuthServiceUrl,
 	})

 	mongoClient, err := connectToMongoDB(ctx, MongoURL)
--- a/tests/integration/mail_test.go
+++ b/tests/integration/mail_test.go
@ -1,11 +1,11 @@
 package integration

 import (
+	"gitea.pena/PenaSide/customer/internal/interface/client"
+	"gitea.pena/PenaSide/customer/internal/models"
 	"github.com/gofiber/fiber/v2"
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/zap"
-	"gitea.pena/PenaSide/customer/internal/interface/client"
-	"gitea.pena/PenaSide/customer/internal/models"
 	"testing"
 )

@ -13,15 +13,14 @@ func TestSendMessage(t *testing.T) {
 	sender := "noreply@mailing.pena.digital"
 	apiKey := "P0YsjUB137upXrr1NiJefHmXVKW1hmBWlpev"

-	mailClient := client.NewMailClient(client.MailClientDeps{
+	mailClient := client.NewMailClient(models.MailClientCfg{
 		ApiUrl:      "https://api.smtp.bz/v1/smtp/send",
 		Sender:      sender,
 		ApiKey:      apiKey,
 		Auth:        &models.PlainAuth{Username: "kotilion.95@gmail.com", Password: "vWwbCSg4bf0p"},
 		FiberClient: fiber.AcquireClient(),
-		Logger:      zap.NewExample(),
 		MailAddress: "pashamullin2001@gmail.com",
-	})
+	}, zap.NewExample())

 	userEmail := "test@example.com"
 	verification := &models.Verification{
--- a/tests/integration/trashLogger_test.go
+++ b/tests/integration/trashLogger_test.go
@ -31,14 +31,12 @@ func TestTrashLogger(t *testing.T) {
 	ptime := time.Now()

 	config := models.Config{
-		Service: models.ServiceConfiguration{
 		TrashLogHost: "localhost:7113",
-		},
 	}

 	ctx := context.Background()

-	clickHouseLogger, err := zaptrashlog.NewCore(ctx, zap.InfoLevel, config.Service.TrashLogHost, version, commit, ptime.Unix())
+	clickHouseLogger, err := zaptrashlog.NewCore(ctx, zap.InfoLevel, config.TrashLogHost, version, commit, ptime.Unix())
 	if err != nil {
 		panic(err)
 	}