TP-55555|db additions adjustments in service,handler

internal/client/aws/aws.go

@@ -0,0 +1,26 @@
+package aws
+
+import (
+	"context"
+	"cybertron/configs"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"log"
+)
+
+type Actions struct {
+	S3Client        *s3.Client
+	S3PresignClient *s3.PresignClient
+}
+
+func NewS3client(clientConfig configs.AwsConfig) *Actions {
+	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(clientConfig.Region))
+	if err != nil {
+		log.Fatal(err)
+	}
+	svc := s3.NewFromConfig(cfg)
+	return &Actions{
+		S3Client:        svc,
+		S3PresignClient: s3.NewPresignClient(svc),
+	}
+}

internal/database/project.go

@@ -9,3 +9,13 @@ func InitProjectRepository(dbClient *gorm.DB) *gorm.DB {
 	dbClient.AutoMigrate(&db.Project{})
 	return dbClient
 }
+
+func InitReleaseRepository(dbClient *gorm.DB) *gorm.DB {
+	dbClient.AutoMigrate(&db.Release{})
+	return dbClient
+}
+
+func InitSourceMapRepository(dbClient *gorm.DB) *gorm.DB {
+	dbClient.AutoMigrate(&db.SourcMap{})
+	return dbClient
+}

internal/dependencies/dependencies.go

@@ -2,11 +2,13 @@ package dependencies
 
 import (
 	"cybertron/configs"
+	"cybertron/internal/client/aws"
 	"cybertron/internal/client/document"
 	"cybertron/internal/database"
 	"cybertron/internal/transport/handler"
 	"cybertron/pkg/db"
 	httpclient "cybertron/pkg/httpClient"
+	"cybertron/pkg/kafka/producer"
 	"cybertron/pkg/log"
 	"cybertron/service"
 
@@ -26,16 +28,22 @@ type Service struct {
 	DocumentService  *document.HttpClient
 	ProjectService   *service.ProjectCreator
 	SourceMapService *service.SourceMapService
+	ReleaseService   *service.ReleaseService
+	ExceptionService *service.ExceptionService
+	S3Client         *aws.Actions
 	// Add your service here
 }
 
 type Handler struct {
 	ProjectHandler   *handler.ProjectHandler
 	SourceMapHandler *handler.SourceMapHandler
+	ReleaseHandler   *handler.ReleasesHandler
+	ExceptionHandler *handler.ExceptionHandler
 }
 
 type Repositories struct {
 	ProjectRepository *gorm.DB
+	ReleaseRepository *gorm.DB
 }
 
 func InitDependencies() *Dependencies {
@@ -43,11 +51,17 @@ func InitDependencies() *Dependencies {
 	repositories := initRepositories(dbClient)
 	logger := log.Log
 	httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
+	s3Client := aws.NewS3client(*configs.GetAWSConfig())
+	kafkaProducer := initKafkaProducer()
+
 	documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
-	projectServiceClient := service.NewProjectCreator(logger, dbClient)
+	projectServiceClient := service.NewProjectCreator(logger, dbClient, s3Client, kafkaProducer)
 	sourceMapServiceClient := service.NewSourceMapService(dbClient)
-	services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient)
-	handlers := initHandlers(projectServiceClient, sourceMapServiceClient)
+	releaseServiceClient := service.NewReleaseService(logger, dbClient)
+	exceptionServiceClient := service.NewExceptionService(logger, dbClient, kafkaProducer)
+
+	services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient)
+	handlers := initHandlers(projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient)
 	return &Dependencies{
 		Service:      services,
 		DBClient:     dbClient,
@@ -57,25 +71,37 @@ func InitDependencies() *Dependencies {
 	}
 }
 
-func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService) *Service {
+func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceptionService *service.ExceptionService) *Service {
 	return &Service{
 		DocumentService:  documentService,
 		ProjectService:   projectService,
 		SourceMapService: sourceMapService,
+		ReleaseService:   releaseService,
+		ExceptionService: exceptionService,
 	}
 }
 
 func initRepositories(dbClient *gorm.DB) *Repositories {
 	return &Repositories{
 		ProjectRepository: database.InitProjectRepository(dbClient),
+		ReleaseRepository: database.InitReleaseRepository(dbClient),
 	}
 }
 
-func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService) *Handler {
+func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceotionService *service.ExceptionService) *Handler {
 	projectHandler := handler.NewProjectHandler(projectService)
 	sourceMapHandler := handler.NewSourceMapHandler(sourceMapService)
+	releaseHandler := handler.NewReleaseHandler(releaseService)
+	exceptionHandler := handler.NewExceptionHandler(exceotionService)
 	return &Handler{
 		ProjectHandler:   projectHandler,
 		SourceMapHandler: sourceMapHandler,
+		ReleaseHandler:   releaseHandler,
+		ExceptionHandler: exceptionHandler,
 	}
 }
+
+func initKafkaProducer() producer.KProducer {
+	kafkaProducer := producer.NewKProducer(configs.GetEnv(), configs.GetKafkaConfig())
+	return kafkaProducer
+}

internal/transport/handler/exception.go

@@ -0,0 +1,20 @@
+package handler
+
+import (
+	"cybertron/service"
+	"github.com/gin-gonic/gin"
+)
+
+type ExceptionHandler struct {
+	exceptionService *service.ExceptionService
+}
+
+func (h *ExceptionHandler) CatchErrors(c *gin.Context) {
+	h.exceptionService.CatchErrors(c)
+}
+
+func NewExceptionHandler(es *service.ExceptionService) *ExceptionHandler {
+	return &ExceptionHandler{
+		exceptionService: es,
+	}
+}

internal/transport/handler/project.go

@@ -9,17 +9,12 @@ type ProjectHandler struct {
 	projectCreatorService *service.ProjectCreator
 }
 
-type ProjectBody struct {
-	Name string `json:"name" binding:"required"`
-	Team string `json:"team" binding:"required"`
-}
-
 func (h *ProjectHandler) ProjectCreate(c *gin.Context) {
 	h.projectCreatorService.CreateProject(c)
 }
 
 func (h *ProjectHandler) ProjectGet(c *gin.Context) {
-	h.projectCreatorService.GetProject(c)
+	h.projectCreatorService.ProjectGet(c)
 }
 
 func NewProjectHandler(projectCreatorService *service.ProjectCreator) *ProjectHandler {

internal/transport/handler/releases.go

@@ -0,0 +1,24 @@
+package handler
+
+import (
+	"cybertron/service"
+	"github.com/gin-gonic/gin"
+)
+
+type ReleasesHandler struct {
+	releaseService *service.ReleaseService
+}
+
+func (h *ReleasesHandler) AddRelease(c *gin.Context) {
+	h.releaseService.AddRelease(c)
+}
+
+func (h *ReleasesHandler) GetReleases(c *gin.Context) {
+	h.releaseService.GetReleases(c)
+}
+
+func NewReleaseHandler(rs *service.ReleaseService) *ReleasesHandler {
+	return &ReleasesHandler{
+		releaseService: rs,
+	}
+}

internal/transport/handler/sourceMap.go

@@ -1,7 +1,6 @@
 package handler
 
 import (
-	"cybertron/models/db"
 	"cybertron/service"
 	"net/http"
 
@@ -24,16 +23,5 @@ func (h *SourceMapHandler) GetSourceMap(c *gin.Context) {
 }
 
 func (h *SourceMapHandler) StoreSourceMap(c *gin.Context) {
-	var sourceMap db.SourceMap
-	if err := c.ShouldBindJSON(&sourceMap); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if err := h.sourceMapService.StoreSourceMap(sourceMap); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to store source map"})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"status": "Source map stored successfully"})
+	h.sourceMapService.StoreSourceMap(c)
 }

internal/transport/router/exception.go

@@ -0,0 +1,15 @@
+package router
+
+import (
+	"cybertron/internal/dependencies"
+	"cybertron/internal/transport/handler"
+	"github.com/gin-gonic/gin"
+)
+
+func ExceptionRouter(r *gin.Engine, dep *dependencies.Dependencies) {
+	exceptionHandler := handler.NewExceptionHandler(dep.Service.ExceptionService)
+	exceptionRouterGroup := r.Group("/api/v1")
+	{
+		exceptionRouterGroup.POST("/catch-errors", exceptionHandler.CatchErrors)
+	}
+}

internal/transport/router/releases.go

@@ -0,0 +1,16 @@
+package router
+
+import (
+	"cybertron/internal/dependencies"
+	"cybertron/internal/transport/handler"
+	"github.com/gin-gonic/gin"
+)
+
+func ReleasesRouter(r *gin.Engine, dep *dependencies.Dependencies) {
+	releasesHandler := handler.NewReleaseHandler(dep.Service.ReleaseService)
+	releasesGroup := r.Group("/api/v1")
+	{
+		releasesGroup.POST("/release", releasesHandler.AddRelease)
+		releasesGroup.GET("/releases", releasesHandler.GetReleases)
+	}
+}

internal/transport/server.go

@@ -32,6 +32,8 @@ func (s *Server) router() {
 	router.ReadinessRouter(s.gin)
 	router.ProjectRouter(s.gin, s.dependencies)
 	router.SourceMapRouter(s.gin, s.dependencies.DBClient)
+	router.ReleasesRouter(s.gin, s.dependencies)
+	router.ExceptionRouter(s.gin, s.dependencies)
 }
 
 func (s *Server) Start() {