2

cmd/erp.go

@@ -5,21 +5,20 @@ import (
 	"fmt"
 	"log"
 
-	db "management/internal/db/sqlc"
-	"management/internal/erpserver"
-	"management/internal/erpserver/biz"
 	"management/internal/erpserver/handler"
-	"management/internal/erpserver/store"
+	"management/internal/erpserver/repository"
+	systemrepo "management/internal/erpserver/repository/system"
+	commonservice "management/internal/erpserver/service/v1/common"
+	systemservice "management/internal/erpserver/service/v1/system"
 	"management/internal/pkg/binding"
 	"management/internal/pkg/config"
 	"management/internal/pkg/database"
-	"management/internal/pkg/logger"
 	"management/internal/pkg/middleware"
 	"management/internal/pkg/redis"
 	"management/internal/pkg/session"
-	"management/internal/pkg/snowflake"
 	"management/internal/pkg/tpl"
 
+	"github.com/drhin/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -44,52 +43,110 @@ func runErp(ctx context.Context) error {
 	conf, err := config.New(configPath)
 	checkError(err)
 
-	logger.New(conf.App.Prod)
+	// 初始化数据
+	// dbinit.InitSeed()
 
-	sdb, err := db.NewIStore(ctx, conf.DB)
+	// mustInit(redis.Init)
+
+	err = binding.SetValidatorTrans("zh")
 	checkError(err)
 
+	contextx, err := newAppContext(conf)
+	checkError(err)
+
+	address := fmt.Sprintf("%s:%d", conf.App.Host, conf.App.Port)
+	log.Printf("Starting erp manage server on %s", address)
+	server := InitServer(address, contextx.Router())
+	return server.ListenAndServe()
+}
+
+func newAppContext(conf *config.Config) (*handler.AppContext, error) {
+	// initialize DB
 	dbOptions := &database.PostgreSQLOptions{
 		Addr:     conf.DB.Host,
 		Username: conf.DB.Username,
 		Password: conf.DB.Password,
 		Database: conf.DB.DBName,
 	}
-
-	// 创建并返回数据库连接
 	gdb, err := database.NewPostgreSQL(dbOptions)
-	checkError(err)
-
-	store := store.NewStore(gdb)
-
-	// 初始化数据
-	// dbinit.InitSeed()
-
-	// mustInit(redis.Init)
+	if err != nil {
+		return nil, err
+	}
+	repo := repository.NewStore(gdb)
 
+	// initialize Redis
 	redis, err := redis.New(conf.Redis)
-	checkError(err)
+	if err != nil {
+		return nil, err
+	}
 
-	session := session.New(sdb.Pool(), conf.App.Prod)
+	// initialize Session
+	db, err := gdb.DB()
+	if err != nil {
+		return nil, err
+	}
+	session := session.New(db, conf.App.Prod)
 
-	mustInit(snowflake.Init)
+	// initialize Logger
+	log, err := logger.NewProduction()
+	if err != nil {
+		return nil, err
+	}
 
-	biz := biz.NewBiz(store, sdb, redis, session)
+	ctx := &handler.AppContext{
+		DB:      gdb,
+		Store:   repo,
+		Redis:   redis,
+		Session: session,
+		Config:  conf,
+		Log:     log,
+	}
 
-	middleware := middleware.New(biz.SystemV1(), session)
+	setRepository(ctx)
+	setService(ctx)
+	setMiddleware(ctx)
+	if err := setRender(ctx); err != nil {
+		return nil, err
+	}
 
-	rander, err := tpl.New(session, biz.SystemV1().MenuBiz())
-	checkError(err)
+	return ctx, nil
+}
 
-	err = binding.SetValidatorTrans("zh")
-	checkError(err)
+func setRepository(ctx *handler.AppContext) {
+	ctx.UserRepo = systemrepo.NewUserRepository(ctx.Store)
+	ctx.LoginLogRepo = systemrepo.NewLoginLogRepository(ctx.Store)
+	ctx.AuditLogRepo = systemrepo.NewAuditLogRepository(ctx.Store)
+	ctx.RoleRepo = systemrepo.NewRoleRepository(ctx.Store)
+	ctx.DepartmentRepo = systemrepo.NewDepartmentRepository(ctx.Store)
+	ctx.ConfigRepo = systemrepo.NewConfigRepository(ctx.Store)
+	ctx.RoleMenuRepo = systemrepo.NewRoleMenuRepository(ctx.Store)
+	ctx.MenuRepo = systemrepo.NewMenuRepository(ctx.Store)
+}
 
-	handler := handler.NewHandler(conf, rander, redis, session, biz, middleware)
+func setService(ctx *handler.AppContext) {
+	ctx.CaptchaService = commonservice.NewCaptchaService()
 
-	address := fmt.Sprintf("%s:%d", conf.App.Host, conf.App.Port)
-	log.Printf("Starting erp manage server on %s", address)
-	server := InitServer(address, erpserver.NewRouter(handler, middleware))
-	return server.ListenAndServe()
+	ctx.ConfigService = systemservice.NewConfigService(ctx.ConfigRepo, ctx.Redis)
+	ctx.LoginLogService = systemservice.NewLoginLogService(ctx.LoginLogRepo)
+	ctx.AuditLogService = systemservice.NewAuditLogService(ctx.AuditLogRepo)
+	ctx.RoleService = systemservice.NewRoleService(ctx.RoleRepo)
+	ctx.UserService = systemservice.NewUserService(ctx.Session, ctx.Log, ctx.UserRepo, ctx.RoleService, ctx.LoginLogService)
+	ctx.DepartmentService = systemservice.NewDepartmentService(ctx.DepartmentRepo)
+	ctx.RoleMenuService = systemservice.NewRoleMenuService(ctx.RoleMenuRepo)
+	ctx.MenuService = systemservice.NewMenuService(ctx.Redis, ctx.Store, ctx.MenuRepo, ctx.RoleService, ctx.RoleMenuService)
+}
+
+func setMiddleware(ctx *handler.AppContext) {
+	ctx.Middleware = middleware.New(ctx.Session, ctx.MenuService, ctx.AuditLogService)
+}
+
+func setRender(ctx *handler.AppContext) error {
+	var err error
+	ctx.Render, err = tpl.New(ctx.Session, ctx.MenuService)
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 func checkError(err error) {