204 lines
8.0 KiB
Go
204 lines
8.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
"log/slog"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"backend/internal/modules/auth"
|
|
"backend/internal/modules/categories"
|
|
"backend/internal/modules/contactlinks"
|
|
"backend/internal/modules/customerverification"
|
|
"backend/internal/modules/media"
|
|
"backend/internal/modules/orders"
|
|
"backend/internal/modules/pricing"
|
|
"backend/internal/modules/products"
|
|
"backend/internal/modules/site"
|
|
"backend/internal/modules/telegram"
|
|
"backend/internal/modules/units"
|
|
"backend/internal/modules/users"
|
|
"backend/internal/platform/config"
|
|
"backend/internal/platform/db"
|
|
"backend/internal/platform/logger"
|
|
appmiddleware "backend/internal/platform/middleware"
|
|
"backend/internal/platform/redis"
|
|
)
|
|
|
|
func main() {
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
log.Fatalf("load config: %v", err)
|
|
}
|
|
|
|
appLogger := logger.New(cfg.Server.GinMode == "debug")
|
|
slog.SetDefault(appLogger)
|
|
|
|
database, err := db.Connect(cfg.Database.URL, cfg.Server.GinMode == "debug")
|
|
if err != nil {
|
|
log.Fatalf("connect database: %v", err)
|
|
}
|
|
|
|
redisClient, err := redis.Connect(cfg.Redis.URL)
|
|
if err != nil {
|
|
log.Fatalf("connect redis: %v", err)
|
|
}
|
|
|
|
// --- Site module (wired first: users.Service needs it as its
|
|
// customer-accounts gate) ---
|
|
siteRepo := site.NewRepository(database)
|
|
siteService := site.NewService(siteRepo)
|
|
siteHandler := site.NewHandler(siteService)
|
|
|
|
// --- Users module ---
|
|
usersRepo := users.NewRepository(database)
|
|
usersService := users.NewService(usersRepo, siteService, cfg.Seed)
|
|
usersHandler := users.NewHandler(usersService)
|
|
|
|
// --- Auth module (admin space mounted; customer space wired but not mounted) ---
|
|
refreshStore := auth.NewRefreshStore(redisClient)
|
|
authService := auth.NewService(usersService, refreshStore, cfg.JWT.Secret, cfg.JWT.AccessTTL, cfg.JWT.RefreshTTL)
|
|
adminAuthHandler := auth.NewAdminHandler(authService, cfg.Server.CookieSecure)
|
|
|
|
// Customer auth space: registration/login are gated behind
|
|
// site.Settings.CustomerAccountsEnabled (see auth.CustomerHandler).
|
|
customerAuthHandler := auth.NewCustomerHandler(authService, usersService, siteService, cfg.Server.CookieSecure)
|
|
|
|
// --- Customer identity verification module (spec: age/ID-restricted
|
|
// goods gate). Documents are stored privately, never through media/. ---
|
|
verificationStorage, err := customerverification.NewStorage(cfg.Verification.UploadDir)
|
|
if err != nil {
|
|
log.Fatalf("init verification storage: %v", err)
|
|
}
|
|
verificationRepo := customerverification.NewRepository(database)
|
|
verificationService := customerverification.NewService(verificationRepo, verificationStorage)
|
|
verificationHandler := customerverification.NewHandler(verificationService)
|
|
|
|
// --- Categories module ---
|
|
categoriesRepo := categories.NewRepository(database)
|
|
categoriesService := categories.NewService(categoriesRepo)
|
|
categoriesHandler := categories.NewHandler(categoriesService)
|
|
|
|
// --- Units module ---
|
|
unitsRepo := units.NewRepository(database)
|
|
unitsService := units.NewService(unitsRepo)
|
|
unitsHandler := units.NewHandler(unitsService)
|
|
|
|
// --- Products module ---
|
|
productsRepo := products.NewRepository(database)
|
|
productsService := products.NewService(productsRepo, categoriesRepo)
|
|
productsHandler := products.NewHandler(productsService)
|
|
|
|
// --- Media module (pluggable local/S3 storage). Wired after products:
|
|
// each media file is isolated to the single product it was uploaded
|
|
// for (or to none, e.g. contact link icons) -- Upload validates
|
|
// product_id via productsService, there is no shared media library. ---
|
|
mediaStorage, err := buildMediaStorage(cfg.Media)
|
|
if err != nil {
|
|
log.Fatalf("init media storage: %v", err)
|
|
}
|
|
mediaRepo := media.NewRepository(database)
|
|
mediaService := media.NewService(mediaRepo, mediaStorage, productsService, categoriesRepo, cfg.Media.MaxUploadMB*1024*1024)
|
|
mediaHandler := media.NewHandler(mediaService)
|
|
|
|
// --- Pricing module (quantity-based tiers, spec section 16) ---
|
|
pricingRepo := pricing.NewRepository(database)
|
|
pricingService := pricing.NewService(pricingRepo)
|
|
pricingHandler := pricing.NewHandler(pricingService)
|
|
|
|
// --- Contact links module (admin-defined list of communication apps
|
|
// shown to customers on the storefront: WhatsApp, Telegram, Signal, ...) ---
|
|
contactLinksRepo := contactlinks.NewRepository(database)
|
|
contactLinksService := contactlinks.NewService(contactLinksRepo)
|
|
contactLinksHandler := contactlinks.NewHandler(contactLinksService)
|
|
|
|
// --- Telegram module (notifications, spec section 20) ---
|
|
telegramRepo := telegram.NewRepository(database)
|
|
telegramService := telegram.NewService(telegramRepo, telegram.NewHTTPSender(), appLogger)
|
|
telegramHandler := telegram.NewHandler(telegramService)
|
|
|
|
// --- Orders module (depends on products/units/pricing for authoritative
|
|
// pricing, and on telegram as its pluggable OrderNotifier) ---
|
|
ordersRepo := orders.NewRepository(database)
|
|
ordersService := orders.NewService(ordersRepo, productsService, unitsService, pricingService, telegramService)
|
|
ordersHandler := orders.NewHandler(ordersService)
|
|
|
|
requireAdmin := appmiddleware.RequireAdmin(cfg.JWT.Secret)
|
|
requireCustomer := appmiddleware.RequireCustomer(cfg.JWT.Secret)
|
|
loginRateLimit := appmiddleware.NewPerIPRateLimiter(5, 5).Middleware()
|
|
orderRateLimit := appmiddleware.NewPerIPRateLimiter(10, 10).Middleware()
|
|
|
|
requireOrdersEnabled := orders.RequireOrdersEnabled(siteService)
|
|
requireAccountsEnabled := orders.RequireAccountsEnabled(siteService)
|
|
requireVerifiedIfNeeded := orders.RequireApprovedVerificationIfNeeded(siteService, verificationService)
|
|
|
|
gin.SetMode(cfg.Server.GinMode)
|
|
router := gin.New()
|
|
router.Use(gin.Recovery())
|
|
router.Use(gin.Logger())
|
|
router.Use(appmiddleware.CORS(cfg.Server.CORSOrigin))
|
|
|
|
if cfg.Media.Driver == "local" {
|
|
router.Static("/uploads", cfg.Media.LocalDir)
|
|
}
|
|
|
|
router.GET("/health", func(c *gin.Context) {
|
|
c.JSON(200, gin.H{"status": "ok"})
|
|
})
|
|
|
|
api := router.Group("/api")
|
|
|
|
auth.RegisterAdminRoutes(api, adminAuthHandler, requireAdmin, loginRateLimit)
|
|
auth.RegisterCustomerRoutes(api, customerAuthHandler, requireCustomer, loginRateLimit)
|
|
users.RegisterAdminRoutes(api, usersHandler, requireAdmin)
|
|
site.RegisterRoutes(api, siteHandler, requireAdmin)
|
|
site.RegisterPublicRoutes(api, siteHandler)
|
|
media.RegisterAdminRoutes(api, mediaHandler, requireAdmin)
|
|
media.RegisterPublicRoutes(api, mediaHandler)
|
|
|
|
categories.RegisterAdminRoutes(api, categoriesHandler, requireAdmin)
|
|
categories.RegisterPublicRoutes(api, categoriesHandler)
|
|
|
|
contactlinks.RegisterAdminRoutes(api, contactLinksHandler, requireAdmin)
|
|
contactlinks.RegisterPublicRoutes(api, contactLinksHandler)
|
|
|
|
units.RegisterAdminRoutes(api, unitsHandler, requireAdmin)
|
|
units.RegisterPublicRoutes(api, unitsHandler)
|
|
|
|
products.RegisterAdminRoutes(api, productsHandler, requireAdmin)
|
|
products.RegisterPublicRoutes(api, productsHandler)
|
|
|
|
pricing.RegisterAdminRoutes(api, pricingHandler, requireAdmin)
|
|
pricing.RegisterPublicRoutes(api, pricingHandler)
|
|
|
|
telegram.RegisterAdminRoutes(api, telegramHandler, requireAdmin)
|
|
|
|
customerverification.RegisterCustomerRoutes(api, verificationHandler, requireCustomer)
|
|
customerverification.RegisterAdminRoutes(api, verificationHandler, requireAdmin)
|
|
|
|
orders.RegisterPublicRoutes(api, ordersHandler, orderRateLimit, requireOrdersEnabled, requireAccountsEnabled, requireCustomer, requireVerifiedIfNeeded)
|
|
orders.RegisterCustomerRoutes(api, ordersHandler, requireCustomer)
|
|
orders.RegisterAdminRoutes(api, ordersHandler, requireAdmin)
|
|
|
|
appLogger.Info("starting server", "port", cfg.Server.Port)
|
|
if err := router.Run(":" + cfg.Server.Port); err != nil {
|
|
log.Fatalf("server error: %v", err)
|
|
}
|
|
}
|
|
|
|
func buildMediaStorage(cfg config.MediaConfig) (media.Storage, error) {
|
|
if cfg.Driver == "s3" {
|
|
return media.NewS3Storage(context.Background(), media.S3Config{
|
|
Bucket: cfg.S3Bucket,
|
|
Region: cfg.S3Region,
|
|
Endpoint: cfg.S3Endpoint,
|
|
AccessKeyID: cfg.S3AccessKeyID,
|
|
SecretKey: cfg.S3SecretKey,
|
|
UsePathStyle: cfg.S3UsePathStyle,
|
|
PublicBaseURL: cfg.S3PublicBaseURL,
|
|
})
|
|
}
|
|
return media.NewLocalStorage(cfg.LocalDir, cfg.LocalBaseURL)
|
|
}
|