houston-be/cmd/app/handler/team_handler.go

package handler

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/spf13/viper"
	"houston/common/util"
	"houston/logger"
	"houston/model/customErrors"
	"houston/service/request/team"
	common "houston/service/response/common"
	"houston/service/teamService"
	"net/http"
	"strconv"
)

type TeamHandler struct {
	gin     *gin.Engine
	service teamService.ITeamServiceV2
}

func NewTeamHandler(gin *gin.Engine, service teamService.ITeamServiceV2) *TeamHandler {
	return &TeamHandler{gin: gin, service: service}
}

func (handler *TeamHandler) HandleGetTeamDetails(c *gin.Context) {
	id := c.Param(util.IdParam)

	teamId, err := strconv.Atoi(id)
	if err != nil || teamId <= 0 {
		logger.Error(fmt.Sprintf("invalid team id: %d", teamId))
		c.JSON(http.StatusBadRequest, common.ErrorResponse(errors.New(fmt.Sprintf("invalid team id %d", teamId)), http.StatusBadRequest, nil))
		return
	}
	teamResponse, err := handler.service.GetTeamDetails(uint(teamId))
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}
	c.JSON(http.StatusOK, common.SuccessResponse(teamResponse, http.StatusOK))
}

func (handler *TeamHandler) HandleGetAllTeams(c *gin.Context) {
	teamResponses, err := handler.service.GetAllTeams()

	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}
	c.JSON(http.StatusOK, common.SuccessResponse(teamResponses, http.StatusOK))
}

func (handler *TeamHandler) HandleGetTeam(c *gin.Context) {
	teamId, err := validateGetTeamParams(c)
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	teamResponse, err := handler.service.GetTeam(teamId)
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

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

func (handler *TeamHandler) handleErrorResponse(c *gin.Context, err error) {
	var dataAccessError *customErrors.DataAccessError
	if errors.As(err, &dataAccessError) {
		c.JSON(http.StatusInternalServerError, common.ErrorResponse(err, http.StatusInternalServerError, nil))
		return
	}

	var notFoundError *customErrors.NotFoundError
	if errors.As(err, &notFoundError) {
		c.JSON(http.StatusNotFound, common.ErrorResponse(err, http.StatusNotFound, nil))
		return
	}

	var invalidInputError *customErrors.InvalidInputError
	if errors.As(err, &invalidInputError) {
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
		return
	}

	c.JSON(http.StatusInternalServerError, common.ErrorResponse(err, http.StatusInternalServerError, nil))
}

func (handler *TeamHandler) HandleAddTeam(c *gin.Context) {
	var addTeamRequest team.AddTeamRequest

	if err := c.ShouldBindJSON(&addTeamRequest); err != nil {
		c.JSON(http.StatusBadRequest, common.ErrorResponse(err, http.StatusBadRequest, nil))
		return
	}

	if err := validateAddTeamRequest(addTeamRequest); err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	addTeamResponse, err := handler.service.AddTeam(addTeamRequest, c.GetHeader(util.UserEmailHeader))
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	c.JSON(http.StatusCreated, common.SuccessResponse(addTeamResponse, http.StatusCreated))
}

func (handler *TeamHandler) HandleUpdateTeam(c *gin.Context, updateTeamRequest team.UpdateTeamRequest) {
	if err := validateUpdateTeamRequest(updateTeamRequest); err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	err := handler.service.UpdateTeam(updateTeamRequest, c.GetHeader(util.UserEmailHeader))
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	c.JSON(http.StatusOK, common.SuccessResponse("Team Updated Successfully", http.StatusOK))
}

func (handler *TeamHandler) HandleRemoveMember(c *gin.Context) {
	teamId, userId, err := validateRemoveMemberParams(c)
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	err = handler.service.RemoveTeamMember(teamId, userId, c.GetHeader(util.UserEmailHeader))
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	c.JSON(http.StatusOK, common.SuccessResponse("Member removed successfully", http.StatusOK))
}

func (handler *TeamHandler) HandleMakeManager(c *gin.Context) {
	teamId, memberToMakeManagerId, err := validateMakeManagerParams(c)
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

	err = handler.service.MakeManager(teamId, memberToMakeManagerId, c.GetHeader(util.UserEmailHeader))
	if err != nil {
		handler.handleErrorResponse(c, err)
		return
	}

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

func validateAddTeamRequest(request team.AddTeamRequest) error {
	teamName := request.Name
	minLength := viper.GetInt("TEAM_NAME_MIN_LENGTH")
	maxLength := viper.GetInt("TEAM_NAME_MAX_LENGTH")

	if len(teamName) < minLength || len(teamName) > maxLength {
		return customErrors.NewInvalidInputError(fmt.Sprintf("Team name must be between %v - %v", minLength, maxLength))
	}

	if request.ManagerDetails == nil {
		return customErrors.NewInvalidInputError("Manager details not provided")
	}

	if request.ManagerDetails.Email == nil || util.IsBlank(*request.ManagerDetails.Email) {
		return customErrors.NewInvalidInputError("Manager email not provided")
	}

	if request.ManagerDetails.SeverityId == nil {
		return customErrors.NewInvalidInputError("Manager severity id not provided")
	}

	return nil
}

func validateUpdateTeamRequest(request team.UpdateTeamRequest) error {
	if request.Id == 0 {
		return customErrors.NewInvalidInputError("Team id not provided")
	}

	if request.Members == nil && util.IsBlank(request.PseOnCallId) &&
		util.IsBlank(request.OnCallId) && util.IsBlank(request.SlackChannel) {
		return customErrors.NewInvalidInputError("No fields provided to update")
	}

	if request.Members != nil {
		if request.Members.SeverityId == 0 {
			return customErrors.NewInvalidInputError("Severity id not provided for members to add")
		}

		if len(request.Members.UserEmailIds) == 0 {
			return customErrors.NewInvalidInputError("No user email ids provided for members to add")
		}
	}

	return nil
}

func validateRemoveMemberParams(c *gin.Context) (uint, uint, error) {
	teamId, err := strconv.Atoi(c.Param(util.IdParam))
	if err != nil || teamId == 0 {
		return 0, 0, customErrors.NewInvalidInputError("Invalid team id")
	}

	userId, err := strconv.Atoi(c.Param(util.UserIdParam))
	if err != nil || userId == 0 {
		return 0, 0, customErrors.NewInvalidInputError("Invalid user id")
	}

	return uint(teamId), uint(userId), nil
}

func validateMakeManagerParams(c *gin.Context) (uint, uint, error) {
	teamId, err := strconv.Atoi(c.Param(util.IdParam))
	if err != nil || teamId == 0 {
		return 0, 0, customErrors.NewInvalidInputError("Invalid team id")
	}

	userId, err := strconv.Atoi(c.Param(util.UserIdParam))
	if err != nil || userId == 0 {
		return 0, 0, customErrors.NewInvalidInputError("Invalid user id to make manager")
	}

	return uint(teamId), uint(userId), nil
}

func validateGetTeamParams(c *gin.Context) (uint, error) {
	teamId, err := strconv.Atoi(c.Param(util.IdParam))
	if err != nil || teamId == 0 {
		return 0, customErrors.NewInvalidInputError("Invalid team id")
	}

	return uint(teamId), nil
}