rogee/gochat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(sla): align applied sla reports

Browse Source
This commit is contained in:
rogee
2026-06-05 07:45:54 +08:00
parent 0c6cf1dd27
commit 4f85ef11e4
9 changed files with 708 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/handler/api/v1/sla_policy_handler.go
+251 -21
View File
@@ -1,8 +1,13 @@
package v1
import (
"context"
"encoding/csv"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"github.com/gin-gonic/gin"
@@ -10,6 +15,7 @@ import (
"github.com/gochat/gochat/internal/service"
applogger "github.com/gochat/gochat/pkg/logger"
"github.com/gochat/gochat/pkg/response"
"gorm.io/gorm"
)
// SlaPolicyHandler handles SLA Policy CRUD + applied SLA metrics/download.
@@ -174,7 +180,34 @@ func serializeSlaPolicy(policy *model.SlaPolicy) map[string]any {
}
}
// GetAppliedSlaMetrics retrieves SLA metrics for a conversation.
// ListAppliedSlas returns the Chatwoot SLA reports table payload.
// GET /api/v1/accounts/:account_id/applied_slas
func (h *SlaPolicyHandler) ListAppliedSlas(c *gin.Context) {
accountID := getAccountID(c)
if accountID == 0 {
response.AbortWithStatusError(c, http.StatusUnauthorized, response.ErrUnauthorized, "account not identified")
return
}
filter := parseAppliedSlaReportFilter(c)
page := parseAppliedSlaPage(c)
report, svcErr := h.svc.ListAppliedSlaReports(c.Request.Context(), accountID, filter, page)
if svcErr != nil {
applogger.L().Errorf("List applied SLA reports for account %d: %v", accountID, svcErr)
handleServiceError(c, svcErr)
return
}
c.JSON(http.StatusOK, gin.H{
"payload": serializeAppliedSlaReportItems(c.Request.Context(), h.svc.DB(), report.AppliedSLAs),
"meta": gin.H{
"count": report.Count,
"current_page": report.CurrentPage,
},
})
}
// GetAppliedSlaMetrics retrieves Chatwoot SLA report metrics.
// GET /api/v1/accounts/:account_id/applied_slas/metrics
func (h *SlaPolicyHandler) GetAppliedSlaMetrics(c *gin.Context) {
accountID := getAccountID(c)
@@ -183,31 +216,17 @@ func (h *SlaPolicyHandler) GetAppliedSlaMetrics(c *gin.Context) {
return
}
conversationIDStr := c.Query("conversation_id")
if conversationIDStr == "" {
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, "conversation_id is required")
return
}
conversationID, err := strconv.ParseUint(conversationIDStr, 10, 32)
if err != nil {
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, "invalid conversation_id")
return
}
applied, events, svcErr := h.svc.GetAppliedSlaMetrics(c.Request.Context(), accountID, uint(conversationID))
metrics, svcErr := h.svc.GetAppliedSlaReportMetrics(c.Request.Context(), accountID, parseAppliedSlaReportFilter(c))
if svcErr != nil {
applogger.L().Errorf("Get SLA metrics for account %d, conversation %d: %v", accountID, conversationID, svcErr)
applogger.L().Errorf("Get applied SLA report metrics for account %d: %v", accountID, svcErr)
handleServiceError(c, svcErr)
return
}
response.OK(c, gin.H{
"applied_sla": applied,
"sla_events": events,
})
c.JSON(http.StatusOK, metrics)
}
// GetAppliedSlaDownload retrieves all applied SLAs for export.
// GetAppliedSlaDownload exports missed applied SLAs as Chatwoot CSV.
// GET /api/v1/accounts/:account_id/applied_slas/download
func (h *SlaPolicyHandler) GetAppliedSlaDownload(c *gin.Context) {
accountID := getAccountID(c)
@@ -216,14 +235,225 @@ func (h *SlaPolicyHandler) GetAppliedSlaDownload(c *gin.Context) {
return
}
applied, svcErr := h.svc.GetAppliedSlaDownload(c.Request.Context(), accountID)
applied, svcErr := h.svc.ListAppliedSlaReportDownload(c.Request.Context(), accountID, parseAppliedSlaReportFilter(c))
if svcErr != nil {
applogger.L().Errorf("Get SLA download for account %d: %v", accountID, svcErr)
handleServiceError(c, svcErr)
return
}
response.OK(c, applied)
c.Header("Content-Type", "text/csv")
c.Header("Content-Disposition", "attachment; filename=breached_conversation.csv")
c.String(http.StatusOK, buildAppliedSlaCSV(c, h.svc.DB(), applied))
}
func parseAppliedSlaReportFilter(c *gin.Context) service.AppliedSlaReportFilter {
return service.AppliedSlaReportFilter{
Since: parseUnixQueryTime(c.Query("since")),
Until: parseUnixQueryTime(c.Query("until")),
InboxID: parseOptionalUintQuery(c.Query("inbox_id")),
TeamID: parseOptionalUintQuery(c.Query("team_id")),
SlaPolicyID: parseOptionalUintQuery(c.Query("sla_policy_id")),
LabelList: c.Query("label_list"),
AssignedAgentID: parseOptionalUintQuery(c.Query("assigned_agent_id")),
SLAStatus: c.Query("status"),
}
}
func parseAppliedSlaPage(c *gin.Context) int {
page, err := strconv.Atoi(c.DefaultQuery("page", "1"))
if err != nil || page < 1 {
return 1
}
return page
}
func parseOptionalUintQuery(raw string) *uint {
if raw == "" || raw == "null" || raw == "undefined" {
return nil
}
parsed, err := strconv.ParseUint(raw, 10, 32)
if err != nil || parsed == 0 {
return nil
}
value := uint(parsed)
return &value
}
func parseUnixQueryTime(raw string) *time.Time {
if raw == "" || raw == "0" || raw == "null" || raw == "undefined" {
return nil
}
seconds, err := strconv.ParseInt(raw, 10, 64)
if err == nil {
t := time.Unix(seconds, 0).UTC()
return &t
}
if t, err := time.Parse(time.RFC3339, raw); err == nil {
return &t
}
return nil
}
func serializeAppliedSlaReportItems(ctx context.Context, db *gorm.DB, applied []model.AppliedSLA) []gin.H {
payload := make([]gin.H, 0, len(applied))
for i := range applied {
item := &applied[i]
payload = append(payload, gin.H{
"applied_sla": serializeAppliedSlaReportApplied(item),
"conversation": serializeAppliedSlaReportConversation(ctx, db, item.ConversationID),
"sla_events": serializeSlaEvents(item.SlaEvents),
})
}
return payload
}
func serializeAppliedSlaReportApplied(applied *model.AppliedSLA) gin.H {
return gin.H{
"id": applied.ID,
"sla_id": applied.SlaPolicyID,
"sla_status": applied.SLAStatus,
"created_at": applied.CreatedAt.Unix(),
"updated_at": applied.UpdatedAt.Unix(),
"sla_description": applied.SlaPolicy.Description,
"sla_name": applied.SlaPolicy.Name,
"sla_first_response_time_threshold": applied.SlaPolicy.FirstResponseTimeThreshold,
"sla_next_response_time_threshold": applied.SlaPolicy.NextResponseTimeThreshold,
"sla_only_during_business_hours": applied.SlaPolicy.OnlyDuringBusinessHours,
"sla_resolution_time_threshold": applied.SlaPolicy.ResolutionTimeThreshold,
}
}
func serializeAppliedSlaReportConversation(ctx context.Context, db *gorm.DB, conversationID uint) gin.H {
conversation := findAppliedSlaConversation(ctx, db, conversationID)
if conversation == nil {
return gin.H{"id": conversationID, "contact": gin.H{}, "labels": ""}
}
payload := gin.H{
"id": conversationDisplayID(conversation),
"contact": gin.H{},
"labels": conversation.Labels,
}
if db == nil {
return payload
}
var contact model.Contact
if err := db.WithContext(ctx).First(&contact, conversation.ContactID).Error; err == nil {
payload["contact"] = gin.H{"name": contact.Name}
}
if conversation.AssigneeID != nil && *conversation.AssigneeID != 0 {
var user model.User
if err := db.WithContext(ctx).First(&user, *conversation.AssigneeID).Error; err == nil {
payload["assignee"] = serializeUser(&user, conversation.AccountID)
}
}
return payload
}
func serializeSlaEvents(events []model.SlaEvent) []gin.H {
payload := make([]gin.H, 0, len(events))
for i := range events {
event := events[i]
payload = append(payload, gin.H{
"id": event.ID,
"event_type": event.EventType,
"meta": jsonObject(event.Meta),
"created_at": event.CreatedAt.Unix(),
"updated_at": event.UpdatedAt.Unix(),
})
}
return payload
}
func buildAppliedSlaCSV(c *gin.Context, db *gorm.DB, applied []model.AppliedSLA) string {
var b strings.Builder
w := csv.NewWriter(&b)
_ = w.Write([]string{"Conversation ID", "SLA policy breached", "Assignee", "Team", "Inbox", "Labels", "Conversation link", "Breached events"})
for i := range applied {
item := &applied[i]
conversation := findAppliedSlaConversation(c.Request.Context(), db, item.ConversationID)
row := []string{"", item.SlaPolicy.Name, "", "", "", "", "", appliedSlaEventNames(item.SlaEvents)}
if conversation != nil {
displayID := conversationDisplayID(conversation)
row[0] = strconv.FormatUint(uint64(displayID), 10)
row[4] = lookupInboxName(c.Request.Context(), db, conversation.InboxID)
row[5] = conversation.Labels
row[6] = appliedSlaConversationURL(c, conversation.AccountID, displayID)
if conversation.AssigneeID != nil {
row[2] = lookupUserName(c.Request.Context(), db, *conversation.AssigneeID)
}
if conversation.TeamID != nil {
row[3] = lookupTeamName(c.Request.Context(), db, *conversation.TeamID)
}
}
_ = w.Write(row)
}
w.Flush()
return b.String()
}
func findAppliedSlaConversation(ctx context.Context, db *gorm.DB, conversationID uint) *model.Conversation {
if db == nil || conversationID == 0 {
return nil
}
var conversation model.Conversation
if err := db.WithContext(ctx).First(&conversation, conversationID).Error; err != nil {
return nil
}
return &conversation
}
func lookupUserName(ctx context.Context, db *gorm.DB, userID uint) string {
if db == nil || userID == 0 {
return ""
}
var user model.User
if err := db.WithContext(ctx).First(&user, userID).Error; err != nil {
return ""
}
return user.Name
}
func lookupTeamName(ctx context.Context, db *gorm.DB, teamID uint) string {
if db == nil || teamID == 0 {
return ""
}
var team model.Team
if err := db.WithContext(ctx).First(&team, teamID).Error; err != nil {
return ""
}
return team.Name
}
func lookupInboxName(ctx context.Context, db *gorm.DB, inboxID uint) string {
if db == nil || inboxID == 0 {
return ""
}
var inbox model.Inbox
if err := db.WithContext(ctx).First(&inbox, inboxID).Error; err != nil {
return ""
}
return inbox.Name
}
func appliedSlaEventNames(events []model.SlaEvent) string {
names := make([]string, 0, len(events))
for i := range events {
names = append(names, string(events[i].EventType))
}
return strings.Join(names, ", ")
}
func appliedSlaConversationURL(c *gin.Context, accountID uint, displayID uint) string {
path := fmt.Sprintf("/app/accounts/%d/conversations/%d", accountID, displayID)
if c.Request == nil || c.Request.Host == "" {
return path
}
scheme := "http"
if c.Request.TLS != nil {
scheme = "https"
}
return scheme + "://" + c.Request.Host + path
}
// ListInboxes retrieves all inboxes associated with a SLA policy.
internal/handler/api/v1/sla_policy_handler_test.go
+133 -56
View File
@@ -7,6 +7,7 @@ import (
"net/http/httptest"
"strconv"
"testing"
"time"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/assert"
@@ -35,6 +36,11 @@ func setupSlaPolicyHandlerTest(t *testing.T) (*SlaPolicyHandler, *gorm.DB) {
&model.SlaPolicyInbox{},
&model.AppliedSLA{},
&model.SlaEvent{},
&model.Inbox{},
&model.Contact{},
&model.Conversation{},
&model.User{},
&model.Team{},
))
t.Cleanup(func() {
sqlDB, _ := db.DB()
@@ -58,7 +64,9 @@ func setupSlaPolicyHandlerTest(t *testing.T) (*SlaPolicyHandler, *gorm.DB) {
func createSlaHandlerTestConversation(db *gorm.DB, accountID uint) *model.Conversation {
inbox := &model.Inbox{AccountID: accountID, Name: "test-inbox", ChannelType: "web_widget"}
db.Create(inbox)
conv := &model.Conversation{AccountID: accountID, InboxID: inbox.ID, Status: "open"}
contact := &model.Contact{AccountID: accountID, Name: "SLA Contact"}
db.Create(contact)
conv := &model.Conversation{AccountID: accountID, InboxID: inbox.ID, ContactID: contact.ID, Status: "open"}
db.Create(conv)
return conv
}
@@ -87,6 +95,7 @@ func setupSlaPolicyTestRouter(handler *SlaPolicyHandler) *gin.Engine {
rg.GET("/sla_policies/:id/inboxes", handler.ListInboxes)
rg.POST("/sla_policies/:id/inboxes", handler.AddInbox)
rg.DELETE("/sla_policies/:id/inboxes/:inbox_id", handler.RemoveInbox)
rg.GET("/applied_slas", handler.ListAppliedSlas)
rg.GET("/applied_slas/metrics", handler.GetAppliedSlaMetrics)
rg.GET("/applied_slas/download", handler.GetAppliedSlaDownload)
return r
@@ -466,63 +475,82 @@ func TestSlaPolicyHandler_ListInboxes_Success(t *testing.T) {
assert.Equal(t, http.StatusOK, w.Code)
}
// ========== GetAppliedSlaMetrics ==========
// ========== Applied SLA reports ==========
func TestSlaPolicyHandler_GetAppliedSlaMetrics_Success(t *testing.T) {
func TestSlaPolicyHandler_ListAppliedSlas_ChatwootPayloadAndFilters(t *testing.T) {
handler, db := setupSlaPolicyHandlerTest(t)
router := setupSlaPolicyTestRouter(handler)
aid := slaHandlerAccountID(db)
accountUID := slaHandlerAccountIDUint(db)
now := time.Now().UTC()
svc := service.NewSlaPolicyService(
repository.NewSlaPolicyRepo(db),
repository.NewAppliedSlaRepo(db),
repository.NewSlaEventRepo(db),
repository.NewSlaPolicyInboxRepo(db),
)
policy, _ := svc.Create(nil, accountUID, &service.CreateSlaPolicyRequest{
Name: "Test SLA", FirstResponseTimeThreshold: 10, NextResponseTimeThreshold: 20, ResolutionTimeThreshold: 100,
})
applied := &model.AppliedSLA{
AccountID: accountUID,
ConversationID: 1,
SlaPolicyID: policy.ID,
}
require.NoError(t, db.Create(applied).Error)
event := &model.SlaEvent{AppliedSlaID: applied.ID, EventType: "frt_reached"}
require.NoError(t, db.Create(event).Error)
policy, conversation, assignee := seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusActiveWithMisses, "vip, urgent", now.Add(-time.Hour))
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusHit, "vip", now.Add(-time.Hour))
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusMissed, "other", now.Add(-time.Hour))
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/api/v1/accounts/"+aid+"/applied_slas/metrics?conversation_id=1", nil)
url := "/api/v1/accounts/" + aid + "/applied_slas?" +
"since=" + strconv.FormatInt(now.Add(-2*time.Hour).Unix(), 10) +
"&until=" + strconv.FormatInt(now.Add(time.Hour).Unix(), 10) +
"&inbox_id=" + strconv.FormatUint(uint64(conversation.InboxID), 10) +
"&team_id=" + strconv.FormatUint(uint64(*conversation.TeamID), 10) +
"&assigned_agent_id=" + strconv.FormatUint(uint64(assignee.ID), 10) +
"&sla_policy_id=" + strconv.FormatUint(uint64(policy.ID), 10) +
"&label_list=urgent&page=1"
req, _ := http.NewRequest("GET", url, nil)
router.ServeHTTP(w, req)
assert.Equal(t, http.StatusOK, w.Code)
var got map[string]interface{}
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &got))
assert.NotContains(t, got, "success")
payload := got["payload"].([]interface{})
require.Len(t, payload, 1)
item := payload[0].(map[string]interface{})
applied := item["applied_sla"].(map[string]interface{})
assert.Equal(t, "Gold SLA", applied["sla_name"])
assert.Equal(t, "active_with_misses", applied["sla_status"])
assert.Equal(t, float64(10), applied["sla_first_response_time_threshold"])
conversationPayload := item["conversation"].(map[string]interface{})
assert.Equal(t, float64(*conversation.DisplayID), conversationPayload["id"])
assert.Equal(t, "vip, urgent", conversationPayload["labels"])
contact := conversationPayload["contact"].(map[string]interface{})
assert.Equal(t, "SLA Contact", contact["name"])
assigneePayload := conversationPayload["assignee"].(map[string]interface{})
assert.Equal(t, "Agent One", assigneePayload["name"])
events := item["sla_events"].([]interface{})
require.Len(t, events, 1)
assert.Equal(t, "nrt", events[0].(map[string]interface{})["event_type"])
meta := got["meta"].(map[string]interface{})
assert.Equal(t, float64(1), meta["count"])
assert.Equal(t, float64(1), meta["current_page"])
}
func TestSlaPolicyHandler_GetAppliedSlaMetrics_MissingConversationID(t *testing.T) {
func TestSlaPolicyHandler_GetAppliedSlaMetrics_ChatwootReportShape(t *testing.T) {
handler, db := setupSlaPolicyHandlerTest(t)
router := setupSlaPolicyTestRouter(handler)
aid := slaHandlerAccountID(db)
accountUID := slaHandlerAccountIDUint(db)
now := time.Now().UTC()
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusHit, "vip", now.Add(-time.Hour))
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusMissed, "vip", now.Add(-time.Hour))
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusActiveWithMisses, "other", now.Add(-time.Hour))
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/api/v1/accounts/"+aid+"/applied_slas/metrics", nil)
req, _ := http.NewRequest("GET", "/api/v1/accounts/"+aid+"/applied_slas/metrics?label_list=vip", nil)
router.ServeHTTP(w, req)
assert.Equal(t, http.StatusBadRequest, w.Code)
}
func TestSlaPolicyHandler_GetAppliedSlaMetrics_InvalidConversationID(t *testing.T) {
handler, db := setupSlaPolicyHandlerTest(t)
router := setupSlaPolicyTestRouter(handler)
aid := slaHandlerAccountID(db)
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/api/v1/accounts/"+aid+"/applied_slas/metrics?conversation_id=notanumber", nil)
router.ServeHTTP(w, req)
assert.Equal(t, http.StatusBadRequest, w.Code)
assert.Equal(t, http.StatusOK, w.Code)
var got map[string]interface{}
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &got))
assert.Equal(t, float64(2), got["total_applied_slas"])
assert.Equal(t, float64(1), got["number_of_sla_misses"])
assert.Equal(t, "50.0%", got["hit_rate"])
}
func TestSlaPolicyHandler_GetAppliedSlaMetrics_NoAccountID(t *testing.T) {
@@ -546,24 +574,10 @@ func TestSlaPolicyHandler_GetAppliedSlaDownload_Success(t *testing.T) {
router := setupSlaPolicyTestRouter(handler)
aid := slaHandlerAccountID(db)
accountUID := slaHandlerAccountIDUint(db)
now := time.Now().UTC()
svc := service.NewSlaPolicyService(
repository.NewSlaPolicyRepo(db),
repository.NewAppliedSlaRepo(db),
repository.NewSlaEventRepo(db),
repository.NewSlaPolicyInboxRepo(db),
)
policy, _ := svc.Create(nil, accountUID, &service.CreateSlaPolicyRequest{
Name: "Test SLA", FirstResponseTimeThreshold: 10, NextResponseTimeThreshold: 20, ResolutionTimeThreshold: 100,
})
applied := &model.AppliedSLA{
AccountID: accountUID,
SlaPolicyID: policy.ID,
ConversationID: createSlaHandlerTestConversation(db, accountUID).ID,
SLAStatus: model.SLAStatusActive,
}
require.NoError(t, db.Create(applied).Error)
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusMissed, "vip", now.Add(-time.Hour))
seedAppliedSlaReportRecord(t, db, accountUID, model.SLAStatusHit, "vip", now.Add(-time.Hour))
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/api/v1/accounts/"+aid+"/applied_slas/download", nil)
@@ -571,5 +585,68 @@ func TestSlaPolicyHandler_GetAppliedSlaDownload_Success(t *testing.T) {
router.ServeHTTP(w, req)
assert.Equal(t, http.StatusOK, w.Code)
assert.Contains(t, w.Body.String(), "account_id")
assert.Equal(t, "attachment; filename=breached_conversation.csv", w.Header().Get("Content-Disposition"))
assert.Contains(t, w.Body.String(), "Conversation ID,SLA policy breached,Assignee,Team,Inbox,Labels,Conversation link,Breached events")
assert.Contains(t, w.Body.String(), "Gold SLA")
assert.Contains(t, w.Body.String(), "frt")
assert.NotContains(t, w.Body.String(), "hit")
}
func seedAppliedSlaReportRecord(t *testing.T, db *gorm.DB, accountID uint, status model.SLAStatus, labels string, createdAt time.Time) (*model.SlaPolicy, *model.Conversation, *model.User) {
t.Helper()
policy := &model.SlaPolicy{
AccountID: accountID,
Name: "Gold SLA",
Description: "Gold support",
FirstResponseTimeThreshold: 10,
NextResponseTimeThreshold: 20,
ResolutionTimeThreshold: 30,
}
require.NoError(t, db.Create(policy).Error)
inbox := &model.Inbox{AccountID: accountID, Name: "Priority", ChannelType: "web_widget", ChannelID: 1}
require.NoError(t, db.Create(inbox).Error)
contact := &model.Contact{AccountID: accountID, Name: "SLA Contact"}
require.NoError(t, db.Create(contact).Error)
assignee := &model.User{AccountID: accountID, Name: "Agent One", Email: "agent-" + strconv.FormatInt(time.Now().UnixNano(), 10) + "@example.com", Password: "secret", Role: "agent"}
require.NoError(t, db.Create(assignee).Error)
team := &model.Team{AccountID: accountID, Name: "Escalation"}
require.NoError(t, db.Create(team).Error)
displayID := uint(100 + time.Now().UnixNano()%100000)
conversation := &model.Conversation{
AccountID: accountID,
InboxID: inbox.ID,
ContactID: contact.ID,
AssigneeID: &assignee.ID,
TeamID: &team.ID,
DisplayID: &displayID,
Status: "open",
ChannelType: "Channel::WebWidget",
Channel: "web_widget",
Labels: labels,
}
require.NoError(t, db.Create(conversation).Error)
applied := &model.AppliedSLA{AccountID: accountID, ConversationID: conversation.ID, SlaPolicyID: policy.ID, SLAStatus: status}
require.NoError(t, db.Create(applied).Error)
require.NoError(t, db.Model(applied).Updates(map[string]any{"created_at": createdAt, "updated_at": createdAt}).Error)
applied.CreatedAt = createdAt
applied.UpdatedAt = createdAt
if status == model.SLAStatusMissed || status == model.SLAStatusActiveWithMisses {
eventType := model.SLAEventFRT
if status == model.SLAStatusActiveWithMisses {
eventType = model.SLAEventNRT
}
require.NoError(t, db.Create(&model.SlaEvent{
AppliedSlaID: applied.ID,
AccountID: accountID,
ConversationID: conversation.ID,
InboxID: inbox.ID,
SlaPolicyID: policy.ID,
EventType: eventType,
}).Error)
}
return policy, conversation, assignee
}