TP-55555|SourceMap get api from client,post api for storing

internal/dependencies/dependencies.go

@@ -9,6 +9,7 @@ import (
 	httpclient "cybertron/pkg/httpClient"
 	"cybertron/pkg/log"
 	"cybertron/service"
+
 	"go.uber.org/zap"
 	"gorm.io/gorm"
 )
@@ -22,13 +23,15 @@ type Dependencies struct {
 }
 
 type Service struct {
-	DocumentService *document.HttpClient
-	ProjectService  *service.ProjectCreator
+	DocumentService  *document.HttpClient
+	ProjectService   *service.ProjectCreator
+	SourceMapService *service.SourceMapService
 	// Add your service here
 }
 
 type Handler struct {
-	ProjectHandler *handler.ProjectHandler
+	ProjectHandler   *handler.ProjectHandler
+	SourceMapHandler *handler.SourceMapHandler
 }
 
 type Repositories struct {
@@ -42,8 +45,9 @@ func InitDependencies() *Dependencies {
 	httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
 	documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
 	projectServiceClient := service.NewProjectCreator(logger, dbClient)
-	services := initServices(documentServiceClient, projectServiceClient)
-	handlers := initHandlers(projectServiceClient)
+	sourceMapServiceClient := service.NewSourceMapService(dbClient)
+	services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient)
+	handlers := initHandlers(projectServiceClient, sourceMapServiceClient)
 	return &Dependencies{
 		Service:      services,
 		DBClient:     dbClient,
@@ -53,10 +57,11 @@ func InitDependencies() *Dependencies {
 	}
 }
 
-func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator) *Service {
+func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService) *Service {
 	return &Service{
-		DocumentService: documentService,
-		ProjectService:  projectService,
+		DocumentService:  documentService,
+		ProjectService:   projectService,
+		SourceMapService: sourceMapService,
 	}
 }
 
@@ -66,9 +71,11 @@ func initRepositories(dbClient *gorm.DB) *Repositories {
 	}
 }
 
-func initHandlers(projectService *service.ProjectCreator) *Handler {
+func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService) *Handler {
 	projectHandler := handler.NewProjectHandler(projectService)
+	sourceMapHandler := handler.NewSourceMapHandler(sourceMapService)
 	return &Handler{
-		ProjectHandler: projectHandler,
+		ProjectHandler:   projectHandler,
+		SourceMapHandler: sourceMapHandler,
 	}
 }

internal/transport/handler/sourceMap.go

@@ -0,0 +1,39 @@
+package handler
+
+import (
+	"cybertron/models/db"
+	"cybertron/service"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type SourceMapHandler struct {
+	sourceMapService *service.SourceMapService
+}
+
+func NewSourceMapHandler(sourceMapService *service.SourceMapService) *SourceMapHandler {
+	return &SourceMapHandler{
+		sourceMapService: sourceMapService,
+	}
+}
+
+func (h *SourceMapHandler) GetSourceMap(c *gin.Context) {
+	sourceMap := h.sourceMapService.GetSourceMap()
+	c.JSON(http.StatusOK, sourceMap)
+}
+
+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"})
+}

internal/transport/router/sourceMap.go

@@ -0,0 +1,16 @@
+package router
+
+import (
+	"cybertron/internal/transport/handler"
+	"cybertron/service"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func SourceMapRouter(r *gin.Engine, dbClient *gorm.DB) {
+	sourceMapService := service.NewSourceMapService(dbClient)
+	sourceMapHandler := handler.NewSourceMapHandler(sourceMapService)
+	r.GET("/uploadsourcemap", sourceMapHandler.GetSourceMap)
+	r.POST("/storesourcemap", sourceMapHandler.StoreSourceMap)
+}

internal/transport/server.go

@@ -31,6 +31,7 @@ func NewServer(dep *dependencies.Dependencies) *Server {
 func (s *Server) router() {
 	router.ReadinessRouter(s.gin)
 	router.ProjectRouter(s.gin, s.dependencies)
+	router.SourceMapRouter(s.gin, s.dependencies.DBClient)
 }
 
 func (s *Server) Start() {

models/db/SourceMap.go

@@ -5,5 +5,6 @@ import "gorm.io/gorm"
 type SourceMap struct {
 	gorm.Model
 	ReleaseReferenceId string `gorm:"primaryKey"`
-	SourceMapZipUrl    string `gorm:"column:name"`
+	ProjectReferenceId string `gorm:"column:project_reference_id"`
+	SourceMapZipUrl    string `gorm:"column:source_map_zip_url"`
 }

service/sourceMap.go

@@ -0,0 +1,39 @@
+package service
+
+import (
+	"cybertron/models/db"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type SourceMapService struct {
+	dbClient *gorm.DB
+}
+
+func NewSourceMapService(dbClient *gorm.DB) *SourceMapService {
+	return &SourceMapService{
+		dbClient: dbClient,
+	}
+}
+
+func (s *SourceMapService) GetSourceMap() db.SourceMap {
+	//fetching SourceMap from a client API
+	sourceMap := db.SourceMap{
+		Model: gorm.Model{
+			ID:        1,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+			DeletedAt: gorm.DeletedAt{},
+		},
+		ReleaseReferenceId: "some-release-ref-id",
+		ProjectReferenceId: "some-project-ref-id",
+		SourceMapZipUrl:    "http://example.com/sourcemap.zip",
+	}
+
+	return sourceMap
+}
+
+func (s *SourceMapService) StoreSourceMap(sourceMap db.SourceMap) error {
+	return s.dbClient.Create(&sourceMap).Error
+}