houston-be/service/severity_service.go

package service

import (
	"fmt"
	commonutil "houston/common/util"
	"houston/logger"
	"houston/pkg/slackbot"
	"houston/repository/severity"
	request "houston/service/request"
	service "houston/service/response"
	common "houston/service/response/common"
	utils "houston/service/utils"
	"net/http"
	"strconv"

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

type severityService struct {
	gin    *gin.Engine
	db     *gorm.DB
	client *slackbot.Client
}

func NewSeverityService(gin *gin.Engine, db *gorm.DB, client *slackbot.Client) *severityService {
	return &severityService{
		gin:    gin,
		db:     db,
		client: client,
	}
}

func (s *severityService) GetSeverities(c *gin.Context) {
	sevId := c.Param("id")
	severityService := severity.NewSeverityRepository(s.db)

	if sevId != "" {
		SevId, err := strconv.Atoi(sevId)
		if err != nil {
			logger.Error("error in parsing sevId", zap.String("sevId", sevId), zap.Error(err))
			c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
			return
		}
		sev, err := severityService.FindSeverityById(uint(SevId))
		if err != nil {
			logger.Error("error in fetching severity by id", zap.Any("SevId", SevId))
			c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
			return
		}
		var userResponses []service.UserResponse
		for _, userId := range sev.SlackUserIds {
			usersInfo, err := s.client.GetUsersInfo(userId)
			if err != nil || len(*usersInfo) == 0 {
				logger.Error("error in getting user info", zap.String("userId", userId), zap.Error(err))
				c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
				return
			}
			users := *usersInfo
			userResponses = append(userResponses, service.UserResponse{
				Id:    users[0].ID,
				Name:  users[0].Profile.RealName,
				Email: users[0].Profile.Email,
				Image: users[0].Profile.Image32,
			})
		}
		sevResponse := service.ConvertToSeverityResponse(*sev)
		sevResponse.Participants = userResponses
		c.JSON(http.StatusOK, common.SuccessResponse(sevResponse, http.StatusOK))
		return
	}

	severityEntities, err := severityService.GetAllActiveSeverity()
	if err != nil {
		logger.Error("error in fetching severties", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
	}

	var severityResponses []service.SeverityResponse
	for _, severity := range *severityEntities {
		severityResponses = append(severityResponses, service.SeverityResponse{
			Id:           severity.ID,
			Name:         severity.Name,
			Description:  severity.Description,
			Sla:          severity.Sla,
			SlackUserIds: severity.SlackUserIds,
			UpdatedAt:    severity.Model.UpdatedAt,
		})
	}

	c.JSON(http.StatusOK, common.SuccessResponse(severityResponses, http.StatusOK))
}

func (s *severityService) UpdateSeverities(c *gin.Context) {
	userEmail := c.GetHeader("X-User-Email")

	var updateSeverityRequest request.UpdateSeveritiesRequest
	if err := c.ShouldBindJSON(&updateSeverityRequest); err != nil {
		c.JSON(http.StatusInternalServerError, common.ErrorResponse(err, http.StatusBadRequest, nil))
		return
	}

	logger.Info("update request received", zap.String("userEmail", userEmail), zap.Any("request", updateSeverityRequest))

	err := utils.ValidateUpdateSeverityRequest(updateSeverityRequest)
	if err != nil {
		logger.Error("error in validating update severties request", zap.Error(err))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
		return
	}

	severityService := severity.NewSeverityRepository(s.db)

	for _, severity := range updateSeverityRequest.Severities {
		severityEntity, err := severityService.FindSeverityById(severity.Id)
		if err != nil {
			logger.Error("error in fetching severtiy", zap.Any("severityId", severity.Id), zap.Error(err))
			c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
			return
		}
		if severity.Name != "" {
			severityEntity.Name = severity.Name
		}
		if severity.Description != "" {
			severityEntity.Description = severity.Description
		}
		if severity.Sla != 0 {
			severityEntity.Sla = severity.Sla
		}
		slackUserIds := []string{}
		if severity.WorkEmailIds != nil {
			for _, ind := range severity.WorkEmailIds {
				slackUser, err := s.client.GetUserByEmail(ind)
				if err != nil {
					logger.Error("error in GetUserByEmail for sev", zap.String("workEmail", ind), zap.Error(err))
				} else {
					slackUserIds = append(slackUserIds, slackUser.ID)
				}
			}
		}
		slackUserIds = append(slackUserIds, severityEntity.SlackUserIds...)
		slackUserIds = commonutil.RemoveDuplicateStr(slackUserIds)
		severityEntity.SlackUserIds = slackUserIds
		err = severityService.Update(severityEntity)
		if err != nil {
			logger.Error("error in updating severity", zap.Any("severityId", severity.Id), zap.Error(err))
			c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
			return
		}
	}

	c.JSON(http.StatusOK, common.SuccessResponse("severity updated successfully", http.StatusOK))
}

func (s *severityService) RemoveMember(c *gin.Context) {
	userEmail := c.GetHeader("X-User-Email")
	sevIdAsString := c.Param("id")
	memberEmailID := c.Param("emailID")
	logger.Info(
		fmt.Sprintf("%s requested to remove %s from severity ID %s", userEmail, memberEmailID, sevIdAsString),
	)
	severityService := severity.NewSeverityRepository(s.db)
	severityID, err := strconv.ParseUint(sevIdAsString, 10, 32)
	if err != nil {
		logger.Error(fmt.Sprintf("error in parsing severity id %s. %+v", sevIdAsString, err))
		c.JSON(
			http.StatusBadRequest,
			common.ErrorResponse(
				fmt.Errorf("%s is not a valid severity ID", sevIdAsString), http.StatusBadRequest, nil,
			),
		)
		return
	}
	severityEntity, err := severityService.FindSeverityById(uint(severityID))
	if err != nil || severityEntity == nil {
		logger.Error(fmt.Sprintf("error in fetching severity by id %d. %+v", severityID, err))
		c.JSON(
			http.StatusBadRequest,
			common.ErrorResponse(
				fmt.Errorf("severity not found for id %d", severityID),
				http.StatusBadRequest,
				nil,
			),
		)
		return
	}
	slackUser, err := s.client.GetUserByEmail(memberEmailID)
	if err != nil {
		logger.Error(fmt.Sprintf("error in fetching user by email %s. %+v", memberEmailID, err))
		c.JSON(
			http.StatusInternalServerError,
			common.ErrorResponse(
				fmt.Errorf("could not find slack account for %s", memberEmailID),
				http.StatusInternalServerError,
				nil,
			),
		)
		return
	}
	if severityEntity.SlackUserIds == nil ||
		len(severityEntity.SlackUserIds) == 0 ||
		!commonutil.Contains(severityEntity.SlackUserIds, slackUser.ID) {
		logger.Error(fmt.Sprintf("no members found for severityID %d", severityID))
		c.JSON(
			http.StatusBadRequest,
			common.ErrorResponse(
				fmt.Errorf("%s is not a member of %s list", memberEmailID, severityEntity.Name),
				http.StatusBadRequest, nil,
			),
		)
		return
	}

	slackUserIds := commonutil.RemoveString(severityEntity.SlackUserIds, slackUser.ID)
	severityEntity.SlackUserIds = slackUserIds
	err = severityService.Update(severityEntity)
	if err != nil {
		logger.Error(fmt.Sprintf("error in removing member from severityID %d. %+v", severityID, err))
		c.JSON(
			http.StatusInternalServerError,
			common.ErrorResponse(
				fmt.Errorf("failed to remove %s from %s", memberEmailID, severityEntity.Name),
				http.StatusInternalServerError,
				nil,
			),
		)
		return
	}
	c.JSON(
		http.StatusOK,
		common.SuccessResponse(
			fmt.Sprintf("%s is removed from %s", memberEmailID, severityEntity.Name),
			http.StatusOK,
		),
	)
}