verification/internal/app/app_verification.go

package app

import (
	"context"
	"fmt"
	mongo "gitea.pena/PenaSide/common/mongo"
	"gitea.pena/PenaSide/customer/pkg/customer_clients"
	"gitea.pena/PenaSide/trashlog/app"
	"gitea.pena/PenaSide/trashlog/wrappers/zaptrashlog"
	"gitea.pena/PenaSide/verification/internal/client"
	"gitea.pena/PenaSide/verification/internal/config"
	"gitea.pena/PenaSide/verification/internal/initialize"
	"gitea.pena/PenaSide/verification/internal/models"
	"gitea.pena/PenaSide/verification/internal/server"
	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
	"gitea.pena/PenaSide/hlog"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"time"
	"os"
)

type Build struct {
	Commit    string
	Version   string
	BuildTime int64
}

func Run(cfg *config.Config, build Build) {
	cfgLogger := zap.NewDevelopmentConfig()
	cfgLogger.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
	cfgLogger.EncoderConfig.ConsoleSeparator = "    "

	logger, err := cfgLogger.Build()
	if err != nil {
		panic(err)
	}

	logger.Info("RUN", zap.Any("ENV", cfg), zap.String("JWT_SECRET", os.Getenv("JWT_SECRET")))

	ctx := context.Background()

	clickHouseLogger, err := zaptrashlog.NewCore(ctx, zap.InfoLevel, cfg.TrashLogHost, build.Version, build.Commit, build.BuildTime)
	if err != nil {
		panic(err)
	}

	loggerForHlog := logger.WithOptions(zap.WrapCore(func(core zapcore.Core) zapcore.Core {
		return zapcore.NewTee(core, clickHouseLogger)
	}), zap.AddCallerSkip(2))

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

	mongoDB, err := mongo.Connect(ctx, &mongo.ConnectDeps{
		Configuration: &cfg.ExternalCfg.Database,
		Timeout:       5 * time.Second,
	})

	if err != nil {
		logger.Fatal("MongoClient", zap.Error(err))
	}

	minioClient, err := minio.New(cfg.S3Endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(cfg.S3AccessKey, cfg.S3SecretKey, ""),
		Secure: true,
	})
	if err != nil {
		logger.Fatal("MinioClient", zap.Error(err))
	}

	reps, err := initialize.NewRepositories(ctx, logger, mongoDB, minioClient, cfg.S3Folder, cfg.S3FileUrl)
	if err != nil {
		logger.Fatal("Repositories", zap.Error(err))
	}

	tgBot, err := tgbotapi.NewBotAPI(cfg.TelegramToken)
	if err != nil {
		logger.Fatal("TelegramBotApi", zap.Error(err))
	}

	_, err = tgBot.Send(tgbotapi.NewMessage(cfg.TelegramChannelID, fmt.Sprintf("PING MSG from %s", config.ModuleLogger)))
	if err != nil {
		logger.Fatal("Send TG ping", zap.Error(err))
	}

	telegram := client.NewTelegram(client.Deps{
		Logger:     logger,
		Bot:        tgBot,
		ChatID:     cfg.TelegramChannelID,
		StagingURL: cfg.VerificationMicroserviceURL,
	})
	cons := initialize.NewControllers(reps, telegram, customer_clients.NewCustomersClient(customer_clients.CustomersClientDeps{
		Logger:              logger,
		CustomerServiceHost: cfg.CustomerMicroserviceRPCURL,
	}))

	userSrv := server.NewHTTP(server.ServerConfig{
		Logger:      logger,
		Controllers: []server.Controller{cons.VerificationUser},
		HLogger:     loggerHlog,
	})

	adminSrv := server.NewHTTP(server.ServerConfig{
		Logger:      logger,
		Controllers: []server.Controller{cons.VerificationAdmin},
		HLogger:     loggerHlog,
	})

	go func() {
		if err := userSrv.Start(cfg.ClientHttpURL); err != nil {
			logger.Fatal("Server startup error", zap.Error(err))
		}
	}()

	go func() {
		if err := adminSrv.Start(cfg.AdminHttpURL); err != nil {
			logger.Fatal("Server startup error", zap.Error(err))
		}
	}()

	gracefulShutdown(ctx, logger, []*server.Server{userSrv, adminSrv}, mongoDB)
}