sarga_updater/main.go

package main

import (
	"fmt"
	"github.com/joho/godotenv"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
	"os"
	"os/signal"
	"sarga_updater/bagisto_models"
	helper "sarga_updater/helpers"
	"sarga_updater/repositories"
	"syscall"
	"time"
)

func init() {
	// logging setup
	helper.Setup()

	log.Println("init function")

	// init .env
	err := godotenv.Load()
	if err != nil {
		log.Fatal(err)
	}
}

func main() {

	fmt.Println("main started")

	// Retrieve database connection information from environment variables
	dsn := os.Getenv("BAZA")
	log.Println("DSN => ", dsn)
	// Connect to the database
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatalf("Error connecting to database: %s", err)
	}

	updatePeriodStr := os.Getenv("UPDATE_PERIOD")
	updatePeriod, err := time.ParseDuration(updatePeriodStr)
	if err != nil {
		log.Fatal("Error parsing update period:", err)
	}
	// Start the worker
	stopCh := make(chan struct{})
	go worker(db, stopCh, updatePeriod)

	// Wait for termination signal
	signalCh := make(chan os.Signal, 1)
	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
	<-signalCh

	// Stop the worker
	close(stopCh)

	// Close the database connection
	sqlDB, err := db.DB()
	if err != nil {
		log.Fatalf("Error getting database connection from gorm: %s", err)
	}
	err = sqlDB.Close()
	if err != nil {
		log.Fatalf("Error closing database connection: %s", err)
	}
}

func worker(db *gorm.DB, stopCh <-chan struct{}, updatePeriod time.Duration) {
	importer, _ := repositories.ParseImporterInstance(db)

	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()
	log.Printf("Updater worker Started")

	for {
		select {
		case <-stopCh:
			return
		case <-ticker.C:

			result, err := bagisto_models.GetFlatSources(importer.Baza)
			if err != nil {
				log.Println("Error retrieving products:", err)
				continue
			} else {
				log.Println(len(result))

			}

			// Update products as needed
			for index, product := range result {
				log.Printf("NO: %d, URL: %s", index, product.TextValue)
				// Retrieve the latest information from the source URL
				parser := repositories.NewLinkParser(product.TextValue)
				data, err := parser.ParseLink()

				if err != nil {
					log.Println("Error decoding product information:", err)
					continue
				}

				jsonProduct, err := parser.GetProductDetailWithOptions(data.ID, data.ProductGroupID)

				if err != nil {
					log.Println("Error getting product information:", err)
					continue
				}

				// Update the product in the database
				if err := importer.UpdateOrCreate(jsonProduct, product.ProductID).Error; err != nil {
					log.Println("Error updateing product information:", err)
				}

			}
			log.Printf("%d Products  updated", len(result))
			ticker = time.NewTicker(updatePeriod)
		}
	}
}