TP-55555 | Release handler refeactor as per services

internal/client/document/document_client.ts.go

@@ -0,0 +1,25 @@
+package document
+
+import (
+	"cybertron/configs"
+	httpclient "cybertron/pkg/httpClient"
+	"cybertron/pkg/log"
+)
+
+type Client interface {
+}
+
+type HttpClient struct {
+	Client
+	HttpClient                       httpclient.HttpClient
+	Logger                           *log.Logger
+	DocumentServiceHttpClientConfigs *configs.DocumentServiceHttpClientConfigs
+}
+
+func NewDocumentServiceHttpClient(httpClient httpclient.HttpClient, logger *log.Logger, documentServiceHttpClientConfigs *configs.DocumentServiceHttpClientConfigs) *HttpClient {
+	return &HttpClient{
+		HttpClient:                       httpClient,
+		Logger:                           logger,
+		DocumentServiceHttpClientConfigs: documentServiceHttpClientConfigs,
+	}
+}

internal/dependencies/dependencies.go

@@ -1,10 +1,14 @@
 package dependencies
 
 import (
+	"cybertron/configs"
+	"cybertron/internal/client/document"
 	"cybertron/internal/database"
 	"cybertron/internal/transport/handler"
 	"cybertron/pkg/db"
+	httpclient "cybertron/pkg/httpClient"
 	"cybertron/pkg/log"
+	"cybertron/service"
 	"go.uber.org/zap"
 	"gorm.io/gorm"
 )
@@ -18,12 +22,15 @@ type Dependencies struct {
 }
 
 type Service struct {
+	DocumentService *document.HttpClient
+	ProjectService  *service.ProjectCreator
+	ReleaseService  *service.ReleaseService
 	// Add your service here
 }
 
 type Handler struct {
-	ProjectHandler  *handler.ProjectHandler
-	ReleasesHandler *handler.ReleasesHandler
+	ProjectHandler *handler.ProjectHandler
+	ReleaseHandler *handler.ReleasesHandler
 }
 
 type Repositories struct {
@@ -32,22 +39,31 @@ type Repositories struct {
 }
 
 func InitDependencies() *Dependencies {
-	services := initServices()
 	dbClient := db.NewDBClient()
-	handlers := initHandlers(dbClient)
 	repositories := initRepositories(dbClient)
+	logger := log.Log
+	httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
+	documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
+	projectServiceClient := service.NewProjectCreator(logger, dbClient)
+	releaseServiceClient := service.NewReleaseService(logger, dbClient)
+
+	services := initServices(documentServiceClient, projectServiceClient, releaseServiceClient)
+	handlers := initHandlers(projectServiceClient, releaseServiceClient)
+
 	return &Dependencies{
 		Service:      services,
 		DBClient:     dbClient,
-		Logger:       log.Log.GetLog(),
+		Logger:       logger.GetLog(),
 		Handler:      handlers,
 		Repositories: repositories,
 	}
 }
 
-func initServices() *Service {
+func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, releaseService *service.ReleaseService) *Service {
 	return &Service{
-		// Add your service here
+		DocumentService: documentService,
+		ProjectService:  projectService,
+		ReleaseService:  releaseService,
 	}
 }
 
@@ -58,12 +74,11 @@ func initRepositories(dbClient *gorm.DB) *Repositories {
 	}
 }
 
-func initHandlers(dbClient *gorm.DB) *Handler {
-	projectHandler := handler.NewProjectHandler(dbClient)
-	releasesHandler := handler.NewReleaseHandler(dbClient)
-
+func initHandlers(projectService *service.ProjectCreator, releaseService *service.ReleaseService) *Handler {
+	projectHandler := handler.NewProjectHandler(projectService)
+	releaseHandler := handler.NewReleaseHandler(releaseService)
 	return &Handler{
-		ProjectHandler:  projectHandler,
-		ReleasesHandler: releasesHandler,
+		ProjectHandler: projectHandler,
+		ReleaseHandler: releaseHandler,
 	}
 }

internal/transport/handler/project.go

@@ -1,57 +1,24 @@
 package handler
 
 import (
-	"cybertron/models/db"
+	"cybertron/service"
 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-	"net/http"
 )
 
 type ProjectHandler struct {
-	dbClient *gorm.DB
-}
-
-type ProjectBody struct {
-	Name string `json:"name" binding:"required"`
-	Team string `json:"team" binding:"required"`
+	projectCreatorService *service.ProjectCreator
 }
 
 func (h *ProjectHandler) ProjectCreate(c *gin.Context) {
-	var projectBody ProjectBody
-	if err := c.BindJSON(&projectBody); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"message": "Invalid Request",
-		})
-		return
-	}
-
-	// Write to database
-	h.dbClient.Create(&db.Project{
-		ProjectReferenceId: uuid.New(),
-		Name:               projectBody.Name,
-		Team:               projectBody.Team,
-	})
-
-	c.JSON(http.StatusOK, gin.H{
-		"message": "Project created",
-	})
+	h.projectCreatorService.ProjectCreate(c)
 }
 
 func (h *ProjectHandler) ProjectGet(c *gin.Context) {
-	var projects []db.Project
-	h.dbClient.Find(&projects)
-
-	if result := h.dbClient.Find(&projects); result.Error != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, projects)
+	h.projectCreatorService.ProjectGet(c)
 }
 
-func NewProjectHandler(dbClient *gorm.DB) *ProjectHandler {
+func NewProjectHandler(projectCreatorService *service.ProjectCreator) *ProjectHandler {
 	return &ProjectHandler{
-		dbClient: dbClient,
+		projectCreatorService: projectCreatorService,
 	}
 }

internal/transport/handler/releases.go

@@ -1,49 +1,24 @@
 package handler
 
 import (
-	"cybertron/models/db"
+	"cybertron/service"
 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-	"net/http"
 )
 
 type ReleasesHandler struct {
-	dbClient *gorm.DB
-}
-
-type ReleaseBody struct {
-	ProjectId string `json:"project_id" binding:"required"`
-	Version   string `json:"version" binding:"required"`
+	releaseService *service.ReleaseService
 }
 
 func (h *ReleasesHandler) AddRelease(c *gin.Context) {
-	var releaseBody ReleaseBody
-	if err := c.BindJSON(&releaseBody); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"message": "Invalid Request",
-		})
-		return
-	}
-
-	releaseToBeAdded := db.Release{
-		ReleaseId:          uuid.New(),
-		ProjectReferenceId: releaseBody.ProjectId,
-		ReleaseVersion:     releaseBody.Version,
-	}
-
-	if result := h.dbClient.Create(&releaseToBeAdded); result.Error != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"message": "Release added successfully",
-	})
+	h.releaseService.AddRelease(c)
 }
 
-func NewReleaseHandler(dbClient *gorm.DB) *ReleasesHandler {
+func (h *ReleasesHandler) GetReleases(c *gin.Context) {
+	h.releaseService.GetReleases(c)
+}
+
+func NewReleaseHandler(rs *service.ReleaseService) *ReleasesHandler {
 	return &ReleasesHandler{
-		dbClient: dbClient,
+		releaseService: rs,
 	}
 }

internal/transport/router/http-client.env.json

@@ -0,0 +1,5 @@
+{
+  "dev": {
+    "name": "value"
+  }
+}

internal/transport/router/project.go

@@ -7,7 +7,7 @@ import (
 )
 
 func ProjectRouter(r *gin.Engine, dep *dependencies.Dependencies) {
-	projectHandler := handler.NewProjectHandler(dep.DBClient)
+	projectHandler := handler.NewProjectHandler(dep.Service.ProjectService)
 	projectRouterGroup := r.Group("/api/v1")
 	{
 		projectRouterGroup.POST("/project", projectHandler.ProjectCreate)

internal/transport/router/releases.go

@@ -7,9 +7,10 @@ import (
 )
 
 func ReleasesRouter(r *gin.Engine, dep *dependencies.Dependencies) {
-	releasesHandler := handler.NewReleaseHandler(dep.DBClient)
+	releasesHandler := handler.NewReleaseHandler(dep.Service.ReleaseService)
 	releasesGroup := r.Group("/api/v1")
 	{
 		releasesGroup.POST("/release", releasesHandler.AddRelease)
+		releasesGroup.GET("/releases", releasesHandler.GetReleases)
 	}
 }