houston-be/service/filter_service.go

package service

import (
	"houston/appcontext"
	"houston/logger"
	"houston/model/incident"
	"houston/model/log"
	"houston/model/team"
	"houston/repository/severity"
	incidentStatus "houston/service/incidentStatus"
	"houston/service/products"
	response "houston/service/response"
	common "houston/service/response/common"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type filterService struct {
	gin                   *gin.Engine
	db                    *gorm.DB
	productService        products.ProductService
	incidentStatusService incidentStatus.IncidentStatusService
}

func NewFilterService(gin *gin.Engine, db *gorm.DB) *filterService {
	return &filterService{
		gin:                   gin,
		db:                    db,
		productService:        appcontext.GetProductsService(),
		incidentStatusService: appcontext.GetIncidentStatusService(),
	}
}

func (f *filterService) GetFilters(c *gin.Context) {
	correlationId := c.GetHeader("X-Correlation-Id")
	logger.Info("Inside GetFilter function", zap.String("correlationId", correlationId))
	var filterResponses []response.FilterResponse

	_, severityRepository, teamRespository := f.GetEntityRepositories()
	incidentStatusFilterData, err := f.GetIncidentStatusFilterData()
	if err != nil {
		logger.Error("error in fetching incident status data", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
	}

	severityFilterData, err := f.GetSeverityFilterData(severityRepository)
	if err != nil {
		logger.Error("error in fetching severity data", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
	}

	productFilterData, err := f.GetProductFilterData()
	if err != nil {
		logger.Error("error in fetching product data", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
	}

	teamFilterData, err := f.GetTeamFilterData(teamRespository)
	if err != nil {
		logger.Error("error in fetching team data", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
	}

	filterResponses = append(filterResponses, *incidentStatusFilterData, *severityFilterData, *productFilterData)
	filterResponses = append(filterResponses, teamFilterData...)
	logger.Info("Exiting GetFilter function", zap.String("correlationId", correlationId))
	c.JSON(http.StatusOK, common.SuccessResponse(filterResponses, http.StatusOK))
}

func (f *filterService) GetEntityRepositories() (
	*incident.Repository, *severity.Repository, *team.Repository) {
	severityRepository := severity.NewSeverityRepository(f.db)
	logRepository := log.NewLogRepository(f.db)
	teamRespository := team.NewTeamRepository(f.db, logRepository)
	incidentRepository := incident.NewIncidentRepository(
		f.db, appcontext.GetSeverityService(), appcontext.GetIncidentStatusService(),
		logRepository, teamRespository, nil,
	)
	return incidentRepository, severityRepository, teamRespository
}

func (f *filterService) GetIncidentStatusFilterData() (*response.FilterResponse, error) {
	incidentStatuses, err := f.incidentStatusService.GetAllIncidentStatuses()
	if err != nil {
		logger.Error("error in fetching incident statues", zap.Error(err))
		return nil, err
	}
	var incidentStatusOptions []response.Options
	for _, incidentStatus := range *incidentStatuses {
		incidentStatusOptions = append(incidentStatusOptions, response.Options{
			Label: incidentStatus.Name,
			Value: strconv.Itoa(int(incidentStatus.ID)),
		})
	}
	filterResponse := response.FilterResponse{
		FilterData:      incidentStatusOptions,
		FilterKey:       "statuses",
		FilterName:      "Incident Status",
		SelectionConfig: "MULTI_SELECT",
	}

	return &filterResponse, nil
}

func (f *filterService) GetSeverityFilterData(severityRepository *severity.Repository) (*response.FilterResponse, error) {
	severityEntities, err := severityRepository.GetAllActiveSeverity()
	if err != nil {
		logger.Error("error in fetching severities", zap.Error(err))
		return nil, err
	}
	var severityOptions []response.Options
	for _, severity := range *severityEntities {
		severityOptions = append(severityOptions, response.Options{
			Label: severity.Name,
			Value: strconv.Itoa(int(severity.ID)),
		})
	}
	filterResponse := response.FilterResponse{
		FilterData:      severityOptions,
		FilterKey:       "severity_ids",
		FilterName:      "Severity",
		SelectionConfig: "MULTI_SELECT",
	}

	return &filterResponse, nil
}

func (f *filterService) GetTeamFilterData(teamRepository *team.Repository) ([]response.FilterResponse, error) {
	priorityTeams := []int{1, 12, 16, 20, 24, 25, 28}
	var priorityTeamOptions []response.Options
	var otherTeamOptions []response.Options
	teamEntities, err := teamRepository.GetAllActiveTeams()
	if err != nil {
		logger.Error("error in fetching incident statues", zap.Error(err))
		return nil, err
	}
	for _, team := range *teamEntities {
		if contains(priorityTeams, int(team.ID)) {
			priorityTeamOptions = append(priorityTeamOptions, response.Options{
				Label: team.Name,
				Value: strconv.Itoa(int(team.ID)),
			})
		} else {
			otherTeamOptions = append(otherTeamOptions, response.Options{
				Label: team.Name,
				Value: strconv.Itoa(int(team.ID)),
			})
		}
	}

	return []response.FilterResponse{
		{
			FilterData:      append(priorityTeamOptions, otherTeamOptions...),
			FilterKey:       "reporter_team_ids",
			FilterName:      "Reporter Team",
			SelectionConfig: "MULTI_SELECT",
		},
		{
			FilterData:      append(priorityTeamOptions, otherTeamOptions...),
			FilterKey:       "team_ids",
			FilterName:      "Responder Team",
			SelectionConfig: "MULTI_SELECT",
		},
	}, nil
}

func (f *filterService) GetProductFilterData() (*response.FilterResponse, error) {
	allProducts, err := f.productService.GetAllProducts()
	if err != nil {
		logger.Error("error in fetching products", zap.Error(err))
		return nil, err
	}
	var productFilterData []response.Options

	for _, productData := range allProducts {
		productFilterData = append(productFilterData, response.Options{
			Label: productData.ProductName,
			Value: strconv.Itoa(int(productData.ProductID)),
		})
	}

	return &response.FilterResponse{
		FilterData:      productFilterData,
		FilterKey:       "product_ids",
		FilterName:      "Product",
		SelectionConfig: "MULTI_SELECT",
	}, nil
}

func contains(inputSlice []int, searchElement int) bool {
	for _, element := range inputSlice {
		if element == searchElement {
			return true
		}
	}
	return false
}