Service does not start automatically upon restarting computer

[Luqman Jr]

After restarting PC I should start service manually even though I set startup type to automatic
How can I fix this

package main

import (
	"flag"
	"fmt"

	"log"
	"os"

	"github.com/goccy/go-json"
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/logger"
	"github.com/kardianos/service"
	"github.com/rngallen/stockIntegration/app/itt"
	"github.com/rngallen/stockIntegration/pkg/config"
	"github.com/rngallen/stockIntegration/pkg/database"
	"github.com/rngallen/stockIntegration/services/logs"
	"github.com/rngallen/stockIntegration/services/middleware"
)

type program struct{}

func (p *program) Start(s service.Service) error {
	// Should be non-blocking, so run async using goroutine
	go p.run()
	return nil
}

// run will be called by Start() so business logic goes here
func (p *program) run() {
	app := fiber.New(fiber.Config{
		Prefork:                 true,
		CaseSensitive:           true,
		StrictRouting:           true,
		ServerHeader:            "Stock Integration",
		AppName:                 "Stock Integration v1.0.0",
		JSONEncoder:             json.Marshal,
		JSONDecoder:             json.Unmarshal,
		EnableTrustedProxyCheck: true,
	})

	// Load Environment Variables
	config.LoadConfig()

	// Application Base Middleware
	middleware.BaseMiddleware(app)

	// Logs
	dir := fmt.Sprintf("%v/stock.log", config.Conf.App.Dir)
	file, err := os.OpenFile(dir, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err.Error())
	}
	defer file.Close()

	// Logger Middleware
	app.Use(logger.New(logger.Config{
		Output:     file,
		Format:     "[${time}] ${ip}:${port} -${protocol} -${method} -${url} -${status} - ${latency}\n",
		TimeFormat: "02-01-2006 15:04:05",
	}))

	// Connect Database
	database.ConnectDb()

	app.Get("/logs", func(c *fiber.Ctx) error {
		return c.SendFile(fmt.Sprintf("%v/logs.log", config.Conf.App.Dir))

	})

	// post transfers
	app.Post("/transfers", func(c *fiber.Ctx) error {
		payload := struct {
			ID int `json:"id"`
		}{}

		if err := c.BodyParser(&payload); err != nil {
			logs.ErrorLogger.Println(err.Error())
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"msg": err.Error()})
		}

		if err := itt.PostIttById(payload.ID); err != nil {
			logs.ErrorLogger.Println(err.Error())
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"msg": err.Error()})
		}
		return c.Status(fiber.StatusCreated).JSON(fiber.Map{"msg": "transfer posted on sage successfully"})
	})

	logs.ErrorLogger.Fatal(app.Listen(config.Conf.App.Port))
}

func (p *program) Stop(s service.Service) error {
	// should be non-blocking
	return nil
}

func main() {
	var mode string
	flag.StringVar(&mode, "mode", "", "install/restart/run/start/stop/uninstall")
	flag.Parse()

	svConfig := &service.Config{
		Name:        "stockApp",
		DisplayName: "Stock & Sage Integration v1.0.0",
		Description: "Integrating Stock application and Sage 300 v1.0.0",
	}

	prg := &program{}
	s, err := service.New(prg, svConfig)
	if err != nil {
		log.Fatal(err)
	}

	switch mode {
	case "run":
		if err = s.Run(); err != nil {
			log.Fatal(err)
		}
	case "start":
		if err = s.Start(); err != nil {
			log.Fatal(err)
		}

	case "stop":
		if err = s.Stop(); err != nil {
			log.Fatal(err)
		}

	case "restart":
		if err = s.Restart(); err != nil {
			log.Fatal(err)
		}

	case "install":
		if err = s.Install(); err != nil {
			log.Fatal(err)
		}

	case "uninstall":
		s.Stop()

		if err = s.Uninstall(); err != nil {
			log.Fatal(err)
		}

	default:
		if err = s.Run(); err != nil {
			log.Fatal(err)
		}
	}
}