tm_back/cmd/worker/bootstrap/bootstrap.go

package bootstrap

import (
	"fmt"
	"time"
	"tm/cmd/worker/workers"
	"tm/internal/notice"
	"tm/internal/tender"
	"tm/pkg/config"
	"tm/pkg/glm"
	"tm/pkg/logger"
	"tm/pkg/mongo"
	"tm/pkg/notification"
	"tm/pkg/ollama"
	"tm/pkg/schedule"
)

// Init Application Configuration
func InitConfig() (*Config, error) {
	conf, err := config.LoadConfig(".", &Config{})
	if err != nil {
		return nil, fmt.Errorf("failed to load config: %v", err)
	}

	return conf, nil
}

// Init Logger Service
func InitLogger(conf config.LoggingConfig) logger.Logger {
	return logger.NewLogger(&logger.Config{
		Level:  conf.Level,
		Format: conf.Format,
		Output: conf.Output,
		File: logger.FileConfig{
			Path:       conf.File.Path,
			MaxSize:    conf.File.MaxSize,
			MaxBackups: conf.File.MaxBackups,
			MaxAge:     conf.File.MaxAge,
			Compress:   conf.File.Compress,
		},
	})
}

// Init MongoDB Connection Manager
func InitMongoDB(conf config.MongoConfig, log logger.Logger) *mongo.ConnectionManager {
	// Convert infra.MongoConfig to mongo.ConnectionConfig
	connectionConfig := mongo.ConnectionConfig{
		URI:                    conf.URI,
		Database:               conf.Name,
		MaxPoolSize:            uint64(conf.MaxPoolSize),
		MinPoolSize:            5,                // Default minimum pool size
		MaxConnIdleTime:        30 * time.Minute, // Default idle time
		ConnectTimeout:         conf.Timeout,
		ServerSelectionTimeout: 5 * time.Second, // Default server selection timeout
	}

	// Create MongoDB connection manager
	connectionManager, err := mongo.NewConnectionManager(connectionConfig, log)
	if err != nil {
		log.Error("Failed to initialize MongoDB connection", map[string]interface{}{
			"error": err.Error(),
			"uri":   conf.URI,
			"db":    conf.Name,
		})
		panic(fmt.Sprintf("Failed to initialize MongoDB connection: %v", err))
	}

	log.Info("MongoDB connection manager initialized successfully", map[string]interface{}{
		"database":  conf.Name,
		"uri":       conf.URI,
		"pool_size": conf.MaxPoolSize,
	})

	return connectionManager
}

// Init Worker
func InitWorker(config Config, mongoManager *mongo.ConnectionManager, appLogger logger.Logger, notify notification.SDK, glmService *glm.SDK) {
	// Initialize repositories
	noticeRepo := notice.NewRepository(mongoManager, appLogger)
	tenderRepo := tender.NewRepository(mongoManager, appLogger)

	worker := workers.NewNoticeWorker(mongoManager, appLogger, &notify, noticeRepo, tenderRepo, glmService)
	worker.Run()

	// start Worker job
	schedule.NewCronScheduler(appLogger, mongoManager, noticeRepo).AddJob(schedule.Job{
		Name: "Worker Job",
		Func: func() {
			worker := workers.NewNoticeWorker(mongoManager, appLogger, &notify, noticeRepo, tenderRepo, glmService)
			worker.Run()
		},
		Expr: config.Worker.Interval,
	})

}

// Init Notification Service
func InitNotificationService(conf config.NotificationConfig, log logger.Logger) notification.SDK {
	notificationConfig := &notification.Config{
		BaseURL:       conf.BaseURL,
		Timeout:       conf.Timeout,
		RetryAttempts: conf.RetryAttempts,
		RetryDelay:    conf.RetryDelay,
		EnableLogging: conf.EnableLogging,
		UserAgent:     conf.UserAgent,
	}

	notificationSDK, err := notification.New(notificationConfig, log)
	if err != nil {
		log.Error("Failed to initialize Notification SDK", map[string]interface{}{
			"error": err.Error(),
		})
		fmt.Printf("Failed to initialize Notification SDK: %v\n", err.Error())
	}

	log.Info("Notification SDK initialized successfully", map[string]interface{}{
		"base_url":       conf.BaseURL,
		"timeout":        conf.Timeout,
		"retry_attempts": conf.RetryAttempts,
		"retry_delay":    conf.RetryDelay,
		"enable_logging": conf.EnableLogging,
		"user_agent":     conf.UserAgent,
	})

	return *notificationSDK
}

// Init Ollama Service
func InitOllamaService(conf config.OllamaConfig, log logger.Logger) *ollama.SDK {
	ollamaSDK, err := ollama.New(&ollama.Config{
		BaseURL:            conf.BaseURL,
		Timeout:            conf.Timeout,
		RetryAttempts:      conf.RetryAttempts,
		RetryDelay:         conf.RetryDelay,
		EnableLogging:      conf.EnableLogging,
		UserAgent:          conf.UserAgent,
		DefaultModel:       conf.DefaultModel,
		DefaultTemperature: conf.DefaultTemperature,
		DefaultTopP:        conf.DefaultTopP,
		DefaultMaxTokens:   conf.DefaultMaxTokens,
		EnableStreaming:    conf.EnableStreaming,
	}, log)
	if err != nil {
		log.Error("Failed to initialize Ollama SDK", map[string]interface{}{
			"error": err.Error(),
		})
	}

	return ollamaSDK
}

// Init GLM Service
func InitGLMService(conf GLMConfig, log logger.Logger) *glm.SDK {
	glmSDK, err := glm.New(
		&glm.Config{
			BaseURL:                 conf.BaseURL,
			APIKey:                  conf.APIKey,
			Timeout:                 conf.Timeout,
			RetryAttempts:           conf.RetryAttempts,
			RetryDelay:              conf.RetryDelay,
			EnableLogging:           conf.EnableLogging,
			UserAgent:               conf.UserAgent,
			DefaultModel:            conf.DefaultModel,
			DefaultMaxTokens:        conf.DefaultMaxTokens,
			DefaultTopP:             conf.DefaultTopP,
			DefaultTemperature:      conf.DefaultTemperature,
			DefaultFrequencyPenalty: conf.DefaultFrequencyPenalty,
			DefaultPresencePenalty:  conf.DefaultPresencePenalty,
			EnableStreaming:         conf.EnableStreaming,
			EnableThinking:          conf.EnableThinking,
			TranslationOptions: glm.TranslationOption{
				Model:            conf.TranslateOptions.Model,
				MaxTokens:        conf.TranslateOptions.MaxTokens,
				Temperature:      conf.TranslateOptions.Temperature,
				FrequencyPenalty: conf.TranslateOptions.FrequencyPenalty,
				PresencePenalty:  conf.TranslateOptions.PresencePenalty,
				TopP:             conf.TranslateOptions.TopP,
				EnableThinking:   conf.TranslateOptions.EnableThinking,
			},
		}, log)

	if err != nil {
		log.Error("Failed to initialize GLM SDK", map[string]interface{}{
			"error": err.Error(),
		})
		panic(fmt.Sprintf("Failed to initialize GLM SDK: %v", err))
	}

	log.Info("GLM SDK initialized successfully", map[string]interface{}{
		"base_url": conf.BaseURL,
		"timeout":  conf.Timeout,
	})

	return glmSDK
}