electricity_bill_calc_service/main.go

package main

import (
	"electricity_bill_calc/config"
	"electricity_bill_calc/global"
	"electricity_bill_calc/model"
	"electricity_bill_calc/router"
	"electricity_bill_calc/service"
	"electricity_bill_calc/utils"
	"encoding/csv"
	"fmt"
	"io"
	"log"
	"os"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	jsontime "github.com/liamylian/jsontime/v2/v2"
	"github.com/shopspring/decimal"
)

func init() {
	err := config.SetupSetting()
	if err != nil {
		log.Fatalf("Configuration load failed: %v", err)
	}
	log.Println("Configuration loaded!")

	err = global.SetupDatabaseConnection()
	if err != nil {
		log.Fatalf("Main Database connect failed: %v", err)
	}
	log.Println("Main Database connected!")

	err = global.DBConn.Sync(
		&model.Region{},
		&model.User{},
		&model.UserDetail{},
		&model.UserCharge{},
		&model.Park{},
		&model.Meter04KV{},
		&model.MaintenanceFee{},
		&model.Report{},
		&model.ReportSummary{},
		&model.WillDilutedFee{},
		&model.EndUserDetail{})
	if err != nil {
		log.Fatalf("Database structure synchronize failed: %v", err)
	}
	log.Println("Database structure synchronized.")

	err = global.SetupRedisConnection()
	if err != nil {
		log.Fatalf("Main Cache Database connect failed: %v", err)
	}
	log.Println("Main Cache Database connected!")

	err = initializeRegions()
	if err != nil {
		log.Fatalf("Regions initialize failed: %v", err)
	}
	log.Println("Regions synchronized.")

	err = intializeSingularity()
	if err != nil {
		log.Fatalf("Singularity account intialize failed: %v", err)
	}
	log.Println("Singularity account intialized.")

	timeZoneShanghai, _ := time.LoadLocation("Asia/Shanghai")
	jsontime.AddTimeFormatAlias("simple_datetime", "2006-01-02 15:04:05")
	jsontime.AddTimeFormatAlias("simple_date", "2006-01-02")
	jsontime.AddLocaleAlias("shanghai", timeZoneShanghai)
}

func initializeRegions() error {
	log.Println("Synchronize regions...")
	regionCsvFile, err := os.Open("regions.csv")
	if err != nil {
		return fmt.Errorf("region initialize file is not found: %w", err)
	}
	defer regionCsvFile.Close()

	var existRegions = make([]string, 0)
	err = global.DBConn.Table("region").Cols("code").Find(&existRegions)
	if err != nil {
		return fmt.Errorf("unable to retreive regions from database: %w", err)
	}

	regionCsv := csv.NewReader(regionCsvFile)
	transaction := global.DBConn.NewSession()
	defer transaction.Close()
	if err = transaction.Begin(); err != nil {
		return fmt.Errorf("unable to intiate database transaction: %w", err)
	}
	for {
		record, err := regionCsv.Read()
		if err == io.EOF {
			break
		}
		if utils.Contains(record[0], existRegions) {
			continue
		}
		level, err := strconv.Atoi(record[2])
		if err != nil {
			continue
		}
		if _, err = transaction.Insert(&model.Region{Code: record[0], Name: record[1], Level: level, Parent: record[3]}); err != nil {
			return fmt.Errorf("region synchronize in failed: %v, %w", record, err)
		}
	}
	if err = transaction.Commit(); err != nil {
		return fmt.Errorf("synchronize regions to database failed: %w", err)
	}
	return nil
}

func intializeSingularity() error {
	singularityExists, err := service.UserService.IsUserExists("000")
	if err != nil {
		return fmt.Errorf("singularity detect failed: %w", err)
	}
	if singularityExists {
		return nil
	}
	singularity := &model.User{
		Id:       "000",
		Username: "singularity",
		Type:     2,
		Enabled:  true,
	}
	singularityName := "Singularity"
	singularityExpires, err := time.Parse("2006-01-02 15:04:05", "2099-12-31 23:59:59")
	if err != nil {
		return fmt.Errorf("singularity expires time parse failed: %w", err)
	}
	singularityDetail := &model.UserDetail{
		Name:              &singularityName,
		UnitServiceFee:    decimal.Zero,
		ServiceExpiration: singularityExpires,
	}
	verifyCode, err := service.UserService.CreateUser(singularity, singularityDetail)
	if err != nil {
		return fmt.Errorf("singularity account failed to create: %w", err)
	}
	log.Printf("Singularity account created, use %s as verify code to reset password.", verifyCode)
	return nil
}

func DBConnectionKeepLive() {
	for range time.Tick(30 * time.Second) {
		err := global.DBConn.Ping()
		if err != nil {
			continue
		}
	}
}

func main() {
	go DBConnectionKeepLive()
	gin.SetMode(config.ServerSettings.RunMode)
	r := router.Router()
	r.Run(fmt.Sprintf(":%d", config.ServerSettings.HttpPort))
}