fix: empty recipients in automated replies

- Make recipients list from the latest message recipients for automated replies

Author: abhinavxd

cmd/conversation.go

@@ -707,8 +707,8 @@ func handleCreateConversation(r *fastglue.Request) error {
 	}
 
 	// Send reply to the created conversation.
-	if err := app.conversation.SendReply(nil /**media**/, inboxID, auser.ID, conversationUUID, content, to, nil /**cc**/, nil /**bcc**/, map[string]any{} /**meta**/); err != nil {
-		// Delete the conversation if sending the reply fails.
+	if err := app.conversation.SendReply(nil /**media**/, inboxID, auser.ID /**sender_id**/, conversationUUID, content, to, nil /**cc**/, nil /**bcc**/, map[string]any{} /**meta**/); err != nil {
+		// Delete the conversation if reply fails.
 		if err := app.conversation.DeleteConversation(conversationUUID); err != nil {
 			app.lo.Error("error deleting conversation", "error", err)
 		}

internal/conversation/conversation.go

@@ -213,6 +213,7 @@ type queries struct {
 	UnsnoozeAll                        *sqlx.Stmt `query:"unsnooze-all"`
 	DeleteConversation                 *sqlx.Stmt `query:"delete-conversation"`
 	RemoveConversationAssignee         *sqlx.Stmt `query:"remove-conversation-assignee"`
+	GetLatestMessage                   *sqlx.Stmt `query:"get-latest-message"`
 
 	// Dashboard queries.
 	GetDashboardCharts string `query:"get-dashboard-charts"`
@@ -870,23 +871,53 @@ func (m *Manager) ApplyAction(action amodels.RuleAction, conv models.Conversatio
 
 	switch action.Type {
 	case amodels.ActionAssignTeam:
-		teamID, _ := strconv.Atoi(action.Value[0])
+		teamID, err := strconv.Atoi(action.Value[0])
+		if err != nil {
+			return fmt.Errorf("invalid team ID %q: %w", action.Value[0], err)
+		}
 		return m.UpdateConversationTeamAssignee(conv.UUID, teamID, user)
 	case amodels.ActionAssignUser:
-		agentID, _ := strconv.Atoi(action.Value[0])
+		agentID, err := strconv.Atoi(action.Value[0])
+		if err != nil {
+			return fmt.Errorf("invalid agent ID %q: %w", action.Value[0], err)
+		}
 		return m.UpdateConversationUserAssignee(conv.UUID, agentID, user)
 	case amodels.ActionSetPriority:
-		priorityID, _ := strconv.Atoi(action.Value[0])
+		priorityID, err := strconv.Atoi(action.Value[0])
+		if err != nil {
+			return fmt.Errorf("invalid priority ID %q: %w", action.Value[0], err)
+		}
 		return m.UpdateConversationPriority(conv.UUID, priorityID, "", user)
 	case amodels.ActionSetStatus:
-		statusID, _ := strconv.Atoi(action.Value[0])
+		statusID, err := strconv.Atoi(action.Value[0])
+		if err != nil {
+			return fmt.Errorf("invalid status ID %q: %w", action.Value[0], err)
+		}
 		return m.UpdateConversationStatus(conv.UUID, statusID, "", "", user)
 	case amodels.ActionSendPrivateNote:
 		return m.SendPrivateNote([]mmodels.Media{}, user.ID, conv.UUID, action.Value[0])
 	case amodels.ActionReply:
-		return m.SendReply([]mmodels.Media{}, conv.InboxID, user.ID, conv.UUID, action.Value[0], nil, nil, nil, nil)
+		// Make recipient list.
+		to, cc, bcc, err := m.makeRecipients(conv.ID, conv.Contact.Email.String, conv.InboxMail)
+		if err != nil {
+			return fmt.Errorf("making recipients for reply action: %w", err)
+		}
+		return m.SendReply(
+			[]mmodels.Media{},
+			conv.InboxID,
+			user.ID,
+			conv.UUID,
+			action.Value[0],
+			to,
+			cc,
+			bcc,
+			map[string]any{}, /**meta**/
+		)
 	case amodels.ActionSetSLA:
-		slaID, _ := strconv.Atoi(action.Value[0])
+		slaID, err := strconv.Atoi(action.Value[0])
+		if err != nil {
+			return fmt.Errorf("invalid SLA ID %q: %w", action.Value[0], err)
+		}
 		return m.ApplySLA(conv, slaID, user)
 	case amodels.ActionAddTags, amodels.ActionSetTags, amodels.ActionRemoveTags:
 		return m.SetConversationTags(conv.UUID, action.Type, action.Value, user)
@@ -922,7 +953,14 @@ func (m *Manager) SendCSATReply(actorUserID int, conversation models.Conversatio
 	meta := map[string]interface{}{
 		"is_csat": true,
 	}
-	return m.SendReply([]mmodels.Media{}, conversation.InboxID, actorUserID, conversation.UUID, message, nil, nil, nil, meta)
+
+	// Make recipient list.
+	to, cc, bcc, err := m.makeRecipients(conversation.ID, conversation.Contact.Email.String, conversation.InboxMail)
+	if err != nil {
+		return fmt.Errorf("making recipients for CSAT reply: %w", err)
+	}
+
+	return m.SendReply(nil /**media**/, conversation.InboxID, actorUserID, conversation.UUID, message, to, cc, bcc, meta)
 }
 
 // DeleteConversation deletes a conversation.

internal/conversation/message.go

@@ -321,7 +321,7 @@ func (m *Manager) SendReply(media []mmodels.Media, inboxID, senderID int, conver
 	bcc = stringutil.RemoveEmpty(bcc)
 
 	if len(to) == 0 {
-		return envelope.NewError(envelope.GeneralError, m.i18n.Ts("globals.messages.empty", "name", "to"), nil)
+		return envelope.NewError(envelope.GeneralError, m.i18n.Ts("globals.messages.empty", "name", "`to`"), nil)
 	}
 	meta["to"] = to
 
@@ -841,3 +841,16 @@ func (m *Manager) uploadThumbnailForMedia(media mmodels.Media, content []byte) e
 	}
 	return nil
 }
+
+// getLatestMessage returns the latest message in a conversation.
+func (m *Manager) getLatestMessage(conversationID int, typ []string, status []string, excludePrivate bool) (models.Message, error) {
+	var message models.Message
+	if err := m.q.GetLatestMessage.Get(&message, conversationID, pq.Array(typ), pq.Array(status), excludePrivate); err != nil {
+		if err == sql.ErrNoRows {
+			return message, sql.ErrNoRows
+		}
+		m.lo.Error("error fetching latest message from DB", "error", err)
+		return message, fmt.Errorf("fetching latest message: %w", err)
+	}
+	return message, nil
+}

internal/conversation/queries.sql

@@ -557,4 +557,24 @@ WHERE
   )
 
 -- name: delete-conversation
-DELETE FROM conversations WHERE uuid = $1;
+DELETE FROM conversations WHERE uuid = $1;
+
+-- name: get-latest-message
+SELECT
+    m.created_at,
+    m.updated_at,
+    m.status,
+    m.type, 
+    m.content,
+    m.uuid,
+    m.private,
+    m.sender_id,
+    m.sender_type,
+    m.meta
+FROM conversation_messages m
+WHERE m.conversation_id = $1
+AND m.type = ANY($2)
+AND m.status = ANY($3)
+AND m.private = NOT $4
+ORDER BY m.created_at DESC
+LIMIT 1;

internal/conversation/recipient.go

@@ -0,0 +1,33 @@
+package conversation
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/abhinavxd/libredesk/internal/conversation/models"
+	"github.com/abhinavxd/libredesk/internal/stringutil"
+)
+
+// makeRecipients computes the recipients for a given conversation ID using the last message in the conversation.
+func (m *Manager) makeRecipients(conversationID int, contactEmail, inboxEmail string) (to, cc, bcc []string, err error) {
+	lastMessage, err := m.getLatestMessage(conversationID, []string{models.MessageIncoming, models.MessageOutgoing}, []string{models.MessageStatusReceived, models.MessageStatusSent}, true)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("fetching message for makeRecipients: %w", err)
+	}
+
+	var meta struct {
+		From []string `json:"from"`
+		To   []string `json:"to"`
+		CC   []string `json:"cc"`
+		BCC  []string `json:"bcc"`
+	}
+	if err = json.Unmarshal(lastMessage.Meta, &meta); err != nil {
+		return nil, nil, nil, err
+	}
+
+	isIncoming := lastMessage.Type == models.MessageIncoming
+	to, cc, bcc = stringutil.ComputeRecipients(
+		meta.From, meta.To, meta.CC, meta.BCC, contactEmail, inboxEmail, isIncoming,
+	)
+	return
+}

internal/stringutil/stringutil.go

@@ -9,6 +9,7 @@ import (
 	"net/url"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strings"
 	"time"
 
@@ -200,3 +201,60 @@ func ExtractEmail(s string) (string, error) {
 	}
 	return addr.Address, nil
 }
+
+// DedupAndExcludeString returns a deduplicated []string excluding empty and a specific value.
+func DedupAndExcludeString(list []string, exclude string) []string {
+	seen := make(map[string]struct{}, len(list))
+	cleaned := make([]string, 0, len(list))
+	for _, s := range list {
+		if s == "" || s == exclude {
+			continue
+		}
+		if _, ok := seen[s]; !ok {
+			seen[s] = struct{}{}
+			cleaned = append(cleaned, s)
+		}
+	}
+	return cleaned
+}
+
+// ComputeRecipients deduplicates and resolves to, cc, and bcc fields.
+// Applies fallback logic using contactEmail and thread rules for incoming messages.
+func ComputeRecipients(
+	from, to, cc, bcc []string,
+	contactEmail, inboxEmail string,
+	lastMessageIncoming bool,
+) (finalTo, finalCC, finalBCC []string) {
+	if lastMessageIncoming {
+		if len(from) > 0 {
+			finalTo = from
+		} else if contactEmail != "" {
+			finalTo = []string{contactEmail}
+		}
+	} else {
+		if len(to) > 0 {
+			finalTo = to
+		} else if contactEmail != "" {
+			finalTo = []string{contactEmail}
+		}
+	}
+
+	finalCC = append([]string{}, cc...)
+
+	if lastMessageIncoming {
+		if len(to) > 0 {
+			finalCC = append(finalCC, to...)
+		}
+		if contactEmail != "" && !slices.Contains(finalTo, contactEmail) && !slices.Contains(finalCC, contactEmail) {
+			finalCC = append(finalCC, contactEmail)
+		}
+	}
+
+	finalBCC = append([]string{}, bcc...)
+
+	finalTo = DedupAndExcludeString(finalTo, inboxEmail)
+	finalCC = DedupAndExcludeString(finalCC, inboxEmail)
+	finalBCC = DedupAndExcludeString(finalBCC, inboxEmail)
+
+	return
+}