optimizing get incident api (#35)

* TP-0000 | invite oncall while incident creation

* TP-0000 | chaning naming on test environment

* TP-0000 | adding log in invite user function

* TP-0000 | renaming query params

* TP-0000 | updating user response

* TP-0000 | updating user response

* TP-0000 | renaming header

* TP-0000 | renaming header

* TP-0000 | renaming header

* TP-0000 | optimizing get incidents

* TP-0000 | removing unwanted changes

* TP-25630 | Removing unwanted changes

pkg/slackbot/users.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/slack-go/slack"
+	"github.com/thoas/go-funk"
 	"go.uber.org/zap"
 )
 
@@ -48,3 +49,18 @@ func (c *Client) GetUserEmailById(userId string) (string, error) {
 	usersInfo := *users
 	return usersInfo[0].Profile.Email, nil
 }
+
+func (c *Client) GetUserEmailsByIds(userIds ...string) (map[string]string, error) {
+	userEmailMapping := make(map[string]string)
+
+	users, err := c.GetUsersInfo(userIds...)
+	if err != nil {
+		c.logger.Error("error in getting user info by id", zap.Any("id", userIds), zap.Error(err))
+		return userEmailMapping, err
+	}
+	usersInfo := *users
+	funk.ForEach(usersInfo, func(userInfo *slack.User) {
+		userEmailMapping[userInfo.ID] = userInfo.Profile.Email		
+	})
+	return userEmailMapping, nil
+}

service/incident_service.go

@@ -23,6 +23,7 @@ import (
 	"github.com/slack-go/slack"
 	"github.com/slack-go/slack/socketmode"
 	"github.com/spf13/viper"
+	"github.com/thoas/go-funk"
 	"go.uber.org/zap"
 	"gorm.io/gorm"
 )
@@ -127,44 +128,70 @@ func (i *incidentService) GetIncidents(c *gin.Context) {
 }
 
 func (i *incidentService) GetIncidentResponseFromIncidentEntity(
-	incidents []incident.IncidentEntity, incidentRepository *incident.Repository, severityRepository *severity.Repository,
-	teamRepository *team.Repository) ([]service.IncidentResponse, error) {
-	var incidentResponses []service.IncidentResponse = []service.IncidentResponse{}
-	for incident := range incidents {
-		incidentResponses = append(incidentResponses, service.ConvertToIncidentResponse(incidents[incident]))
-		team, err := teamRepository.FindTeamById(incidentResponses[incident].TeamId)
-		if err != nil {
-			i.logger.Error("error in fetching team", zap.Error(err))
-			return nil, err
-		}
-		incidentResponses[incident].TeamName = team.Name
+    incidents []incident.IncidentEntity, incidentRepository *incident.Repository, severityRepository *severity.Repository, 
+    teamRepository *team.Repository) ([]service.IncidentResponse, error) {
+    
+    teams, err := teamRepository.GetAllActiveTeams()
+    if err != nil {
+        i.logger.Error("error in fetching teams", zap.Error(err))
+        return nil, err
+    }
 
-		severity, err := severityRepository.FindSeverityById(incidentResponses[incident].SeverityId)
-		if err != nil {
-			i.logger.Error("error in fetching severity", zap.Error(err))
-			return nil, err
-		}
-		incidentResponses[incident].SeverityName = severity.Name
-		incidentStatus, err := incidentRepository.GetIncidentStatusNameByStatus(incidentResponses[incident].Status)
-		if err != nil {
-			i.logger.Error("error in fetching incident status", zap.Error(err))
-			return nil, err
-		}
-		incidentResponses[incident].StatusName = incidentStatus.Name
-		userEmail, err := i.slackbotClient.GetUserEmailById(incidents[incident].CreatedBy)
-		if err != nil {
-			i.logger.Error("error in fetching user name by id", zap.String("userId", incidents[incident].CreatedBy), zap.Error(err))
-			// return nil, err
-		}
-		incidentResponses[incident].CreatedBy = userEmail
-		userEmail, err = i.slackbotClient.GetUserEmailById(incidents[incident].UpdatedBy)
-		if err != nil {
-			i.logger.Error("error in fetching user name by id", zap.String("userId", incidents[incident].UpdatedBy), zap.Error(err))
-			// return nil, err
-		}
-		incidentResponses[incident].UpdatedBy = userEmail
-	}
-	return incidentResponses, nil
+    severities, err := severityRepository.GetAllActiveSeverity()
+    if err != nil {
+        i.logger.Error("error in fetching severities", zap.Error(err))
+        return nil, err
+    }
+
+    incidentStatuses, err := incidentRepository.FetchAllIncidentStatuses()
+    if err != nil {
+        i.logger.Error("error in fetching incidentStatuses", zap.Error(err))
+        return nil, err
+    }
+
+    userEmailMappings, err := i.GetEmailsOfAllIncidentCreatedByAndUpdatedBy(incidents)
+    if err != nil {
+        i.logger.Error("error in fetching user emails mapping by ids", zap.Error(err))
+        return nil, err
+    }
+
+    var incidentResponses []service.IncidentResponse = []service.IncidentResponse{}    
+    for incidentIndex := range incidents {     
+        incidentResponses = append(incidentResponses, service.ConvertToIncidentResponse(incidents[incidentIndex]))
+        team := funk.Find(teams, func(team *team.TeamEntity) bool {
+            return team.ID == incidents[incidentIndex].TeamId
+        }).(team.TeamEntity)  
+        incidentResponses[incidentIndex].TeamName = team.Name
+
+        severity := funk.Find(severities, func(severity *severity.SeverityEntity) bool {
+            return severity.ID == incidents[incidentIndex].SeverityId
+        }).(severity.SeverityEntity)  
+        incidentResponses[incidentIndex].SeverityName = severity.Name
+
+        incidentStatus := funk.Find(incidentStatuses, func(incidentStatus *incident.IncidentStatusEntity) bool {
+            return incidentStatus.ID == incidents[incidentIndex].Status
+        }).(incident.IncidentStatusEntity)
+        incidentResponses[incidentIndex].StatusName = incidentStatus.Name            
+        incidentResponses[incidentIndex].CreatedBy = userEmailMappings[incidents[incidentIndex].CreatedBy]
+        incidentResponses[incidentIndex].UpdatedBy = userEmailMappings[incidents[incidentIndex].UpdatedBy]
+    }
+    return incidentResponses, nil
+}
+
+func (i *incidentService) GetEmailsOfAllIncidentCreatedByAndUpdatedBy(incidents []incident.IncidentEntity) (
+    map[string]string, error) {
+    listOfUserIds := funk.Map(incidents, func(incd incident.IncidentEntity)string {
+        return incd.CreatedBy
+    }).([]string)
+    listOfUserIds = append(listOfUserIds, funk.Map(incidents, func(incd incident.IncidentEntity)string {
+        return incd.UpdatedBy
+    }).([]string)...)
+    userEmailMapping, err := i.slackbotClient.GetUserEmailsByIds(listOfUserIds...)
+    if err != nil {
+        i.logger.Error("error in fetching user emails by ids", zap.Any("listOfUserIds", listOfUserIds), zap.Error(err))
+        return map[string]string{}, err
+    }
+    return userEmailMapping, nil
 }
 
 func (i *incidentService) GetAllIncidents(