varnitgoyal95/cybertron
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TP-55555 | cybertron ui (#13)

Browse Source 
* TP-55555 | cybertron ui

* TP-55555 clean up

* TP-55555 clean up

* TP-55555 | latest push
This commit is contained in:
Varnit Goyal
2024-08-21 13:01:17 +05:30
committed by GitHub
parent f89f1f331d
commit a63d66100a
12 changed files with 319 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
internal/client/elastic/elastic.go Normal file
View File

@@ -0,0 +1,97 @@
package elastic
import (
"context"
"crypto/tls"
"cybertron/configs"
"encoding/json"
elasticsearch8 "github.com/elastic/go-elasticsearch/v8"
"github.com/elastic/go-elasticsearch/v8/typedapi/core/search"
"github.com/elastic/go-elasticsearch/v8/typedapi/types"
"log"
"net/http"
)
type ElasticSearchClient struct {
client *elasticsearch8.TypedClient
Config configs.ElasticConfig
}
func NewElasticClient(elasticConfig configs.ElasticConfig) (*ElasticSearchClient, error) {
cfg := elasticsearch8.Config{
Addresses: elasticConfig.Addresses,
APIKey: elasticConfig.APIKey,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
client, err := elasticsearch8.NewTypedClient(cfg)
return &ElasticSearchClient{
client: client,
Config: elasticConfig,
}, err
}
func (el *ElasticSearchClient) IndexDocument(document interface{}) {
_, err := el.client.Index(el.Config.Index).
Request(document).
Do(context.TODO())
if err != nil {
log.Fatal(err)
}
}
func (el *ElasticSearchClient) SearchDocuments(query *types.Query, fields []string) ([]map[string]interface{}, error) {
res, err := el.client.Search().
Index(el.Config.Index).
Request(&search.Request{
Query: query,
}).Source_(fields).
Do(context.TODO())
if err != nil {
log.Println("Error getting response: %s", err)
}
var results []map[string]interface{}
for _, hit := range res.Hits.Hits {
var doc map[string]interface{}
err := json.Unmarshal(hit.Source_, &doc)
doc["id"] = *hit.Id_
if err != nil {
log.Printf("Error unmarshalling document: %s", err)
continue
}
results = append(results, doc)
}
return results, nil
}
func (el *ElasticSearchClient) GetDocument(documentID string) (interface{}, error) {
// Retrieve the document by its ID
res, err := el.client.Get(el.Config.Index, documentID).Do(context.Background())
var document interface{}
if err != nil {
log.Printf("Error getting response: %s", err)
return nil, err
}
// Check if the document exists
if !res.Found {
log.Printf("Document with ID %s not found", documentID)
return document, nil
}
// Unmarshal the JSON response into the provided document interface
err = json.Unmarshal(res.Source_, &document)
if err != nil {
log.Printf("Error unmarshalling document: %s", err)
return nil, err
}
return document, nil
}

16
internal/dependencies/dependencies.go
View File

@@ -4,6 +4,7 @@ import (
"cybertron/configs"
"cybertron/internal/client/aws"
"cybertron/internal/client/document"
"cybertron/internal/client/elastic"
"cybertron/internal/database"
"cybertron/internal/transport/handler"
"cybertron/pkg/db"
@@ -30,6 +31,7 @@ type Service struct {
SourceMapService *service.SourceMapService
ReleaseService *service.ReleaseService
ExceptionService *service.ExceptionService
SearchService *service.SearchService
S3Client *aws.Actions
// Add your service here
}
@@ -39,6 +41,7 @@ type Handler struct {
SourceMapHandler *handler.SourceMapHandler
ReleaseHandler *handler.ReleasesHandler
ExceptionHandler *handler.ExceptionHandler
SearchHandler *handler.SearchHandler
}
type Repositories struct {
@@ -54,15 +57,17 @@ func InitDependencies() *Dependencies {
httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
s3Client := aws.NewS3client(*configs.GetAWSConfig())
kafkaProducer := initKafkaProducer()
elasticSearch, _ := elastic.NewElasticClient(*configs.GetElasticConfig())
documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
projectServiceClient := service.NewProjectCreator(logger, dbClient, s3Client, kafkaProducer)
sourceMapServiceClient := service.NewSourceMapService(dbClient, s3Client, configs.GetAWSConfig())
releaseServiceClient := service.NewReleaseService(logger, dbClient)
exceptionServiceClient := service.NewExceptionService(logger, dbClient, kafkaProducer)
searchServiceClient := service.NewSearchService(logger, elasticSearch)
services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient)
handlers := initHandlers(projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient)
services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient, searchServiceClient)
handlers := initHandlers(projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient, searchServiceClient)
return &Dependencies{
Service: services,
DBClient: dbClient,
@@ -72,13 +77,14 @@ func InitDependencies() *Dependencies {
}
}
func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceptionService *service.ExceptionService) *Service {
func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceptionService *service.ExceptionService, searchService *service.SearchService) *Service {
return &Service{
DocumentService: documentService,
ProjectService: projectService,
SourceMapService: sourceMapService,
ReleaseService: releaseService,
ExceptionService: exceptionService,
SearchService: searchService,
}
}
@@ -90,16 +96,18 @@ func initRepositories(dbClient *gorm.DB) *Repositories {
}
}
func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceotionService *service.ExceptionService) *Handler {
func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceotionService *service.ExceptionService, searchService *service.SearchService) *Handler {
projectHandler := handler.NewProjectHandler(projectService)
sourceMapHandler := handler.NewSourceMapHandler(sourceMapService)
releaseHandler := handler.NewReleaseHandler(releaseService)
exceptionHandler := handler.NewExceptionHandler(exceotionService)
searchHandler := handler.NewSearchHandler(searchService)
return &Handler{
ProjectHandler: projectHandler,
SourceMapHandler: sourceMapHandler,
ReleaseHandler: releaseHandler,
ExceptionHandler: exceptionHandler,
SearchHandler: searchHandler,
}
}

27
internal/transport/handler/search.go Normal file
View File

@@ -0,0 +1,27 @@
package handler
import (
"cybertron/service"
"github.com/gin-gonic/gin"
)
type SearchHandler struct {
searchService *service.SearchService
}
func (h *SearchHandler) SearchErrors(c *gin.Context) {
h.searchService.GetErrorDetails(c)
}
func (h *SearchHandler) GetErrorDetails(c *gin.Context) {
h.searchService.GetErrorDetails(c)
}
func (h *SearchHandler) GetErrorList(c *gin.Context) {
h.searchService.GetErrorList(c)
}
func NewSearchHandler(s *service.SearchService) *SearchHandler {
return &SearchHandler{
searchService: s,
}
}

17
internal/transport/router/search.go Normal file
View File

@@ -0,0 +1,17 @@
package router
import (
"cybertron/internal/dependencies"
"cybertron/internal/transport/handler"
"github.com/gin-gonic/gin"
)
func SearchRouter(r *gin.Engine, dep *dependencies.Dependencies) {
searchHandler := handler.NewSearchHandler(dep.Service.SearchService)
searchRouterGroup := r.Group("/api/v1")
{
searchRouterGroup.GET("/errors-list", searchHandler.GetErrorList)
searchRouterGroup.GET("/error-detail", searchHandler.GetErrorDetails)
}
}

10
internal/transport/server.go
View File

@@ -3,6 +3,7 @@ package transport
import (
"cybertron/internal/transport/router"
"fmt"
"github.com/gin-contrib/cors"
"os"
"os/signal"
"syscall"
@@ -34,10 +35,19 @@ func (s *Server) router() {
router.SourceMapRouter(s.gin, s.dependencies)
router.ReleasesRouter(s.gin, s.dependencies)
router.ExceptionRouter(s.gin, s.dependencies)
router.SearchRouter(s.gin, s.dependencies)
}
func (s *Server) Start() {
s.gin.Use(ginzap.Ginzap(s.dependencies.Logger, time.RFC3339, false))
s.gin.Use(cors.New(cors.Config{
AllowOrigins: []string{"*"},
AllowMethods: []string{"PUT", "PATCH", "GET", "POST", "OPTIONS"},
AllowHeaders: []string{"*", "x-session-token"},
ExposeHeaders: []string{"Content-Length"},
AllowCredentials: true,
MaxAge: 24 * time.Hour,
}))
s.router()
port := configs.GetPort()