rogee
aeddedf2a3
Restructure the monorepo into clear top-level directories: - backend/: Go module root (cmd, internal, pkg, configs, migrations, docs/swagger, scripts, tests, go.mod, Makefile, .air.toml) - deploy/: Docker (Dockerfile, docker-compose*), quickstart, fluentd - docs/: project documentation + reports/ (moved from repo root) - AGENTS.md: new AI coding-agent guide at repo root Update all references to the new layout: - Dockerfile: COPY backend/go.mod, COPY backend/ (context = repo root) - docker-compose files: context ../.., dockerfile deploy/docker/Dockerfile, env_file ../../.env, volume mounts ../../backend:/app - deploy/quickstart/compose.yaml: dockerfile deploy/docker/Dockerfile - CI: working-directory: backend for go commands, file deploy/docker/Dockerfile, coverage path backend/coverage.out, health_check backend/scripts/ - backend/Makefile: docker target uses -f ../deploy/docker/Dockerfile ../ - README: architecture tree, quickstart, config paths updated Move root stray scripts (rename_models.*, run_m11_tests.sh, verify_build.sh, gorm_bool_main.go) to backend/scripts/legacy/. All moves via git mv to preserve history. Build, vet, SQLite tests, and docker compose config verified.
822 lines
31 KiB
Go
822 lines
31 KiB
Go
package v1
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/gochat/gochat/internal/model"
|
|
"github.com/gochat/gochat/internal/search"
|
|
"github.com/gochat/gochat/pkg/response"
|
|
)
|
|
|
|
const chatwootSearchPerPage = 15
|
|
|
|
var chatwootGlobalSearchTypes = []search.SearchResultType{
|
|
search.ResultTypeConversation,
|
|
search.ResultTypeContact,
|
|
search.ResultTypeMessage,
|
|
search.ResultTypeArticle,
|
|
}
|
|
|
|
// SearchHandler handles global search API endpoints.
|
|
// Reference: Chatwoot GlobalSearchService — cross-entity search with advanced filtering.
|
|
type SearchHandler struct {
|
|
svc *search.SearchService
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewSearchHandler creates a new SearchHandler.
|
|
func NewSearchHandler(svc *search.SearchService, dbs ...*gorm.DB) *SearchHandler {
|
|
h := &SearchHandler{svc: svc}
|
|
if len(dbs) > 0 {
|
|
h.db = dbs[0]
|
|
}
|
|
return h
|
|
}
|
|
|
|
// GlobalSearch performs a unified search across conversations, messages, and contacts.
|
|
// GET /api/v1/accounts/:account_id/search?q=xxx&types=conversation,message&status=open&assignee_id=1
|
|
// Reference: Chatwoot GlobalSearchService — searches across conversations, messages, contacts.
|
|
|
|
// @Summary Global search across all entity types
|
|
// @Description Searches across conversations, messages, contacts, and articles with advanced filtering and pagination
|
|
// @Tags Search
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param account_id path uint true "Account ID"
|
|
// @Param q query string false "Search query string"
|
|
// @Param types query string false "Entity types to search (conversation,message,contact,article)" default(conversation,message,contact,article)
|
|
// @Param search_mode query string false "Search mode: ilike (substring) or trigram (fuzzy)" default(ilike)
|
|
// @Param status query string false "Conversation status filter (open,resolved,pending,snoozed)"
|
|
// @Param priority query string false "Conversation priority filter (none,low,medium,high,urgent)"
|
|
// @Param assignee_id query int false "Assignee agent ID filter"
|
|
// @Param team_id query int false "Team ID filter"
|
|
// @Param inbox_id query int false "Inbox ID filter"
|
|
// @Param labels query string false "Label filter (comma-separated)"
|
|
// @Param contact_source query string false "Contact source filter (email,phone,website,api)"
|
|
// @Param message_type query string false "Message type filter (incoming,outgoing,activity)"
|
|
// @Param sender_type query string false "Sender type filter"
|
|
// @Param content_type query string false "Content type filter (text,input_email,card)"
|
|
// @Param private query bool false "Private message filter"
|
|
// @Param date_from query string false "Date range start (ISO 8601)"
|
|
// @Param date_to query string false "Date range end (ISO 8601)"
|
|
// @Param portal_id query int false "Portal ID filter (for article search)"
|
|
// @Param article_status query string false "Article status filter (draft,published,archived)"
|
|
// @Param article_locale query string false "Article locale filter"
|
|
// @Param sort_by query string false "Sort field (created_at,last_activity_at,updated_at)" default(created_at)
|
|
// @Param sort_order query string false "Sort order (asc,desc)" default(desc)
|
|
// @Param page query int false "Page number" default(1)
|
|
// @Param per_page query int false "Ignored for Chatwoot parity; search results are fixed at 15 per page" default(15)
|
|
// @Success 200 {object} search.SearchResponse
|
|
// @Failure 400 {object} model.ErrorResponse
|
|
// @Failure 401 {object} model.ErrorResponse
|
|
// @Failure 500 {object} model.ErrorResponse
|
|
// @Security ApiKeyAuth
|
|
// @Router /api/v1/accounts/{account_id}/search [get]
|
|
func (h *SearchHandler) GlobalSearch(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account id")
|
|
return
|
|
}
|
|
|
|
query := c.Query("q")
|
|
filter := parseChatwootSearchFilter(c, "global")
|
|
filter.Types = append([]search.SearchResultType(nil), chatwootGlobalSearchTypes...)
|
|
|
|
result, svcErr := h.svc.GlobalSearch(c.Request.Context(), accountID, query, &filter)
|
|
if svcErr != nil {
|
|
response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, "search failed")
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"payload": serializeSearchPayload(c.Request.Context(), h.db, result.Results)})
|
|
}
|
|
|
|
// SearchConversations performs a conversation-only search with advanced filters.
|
|
// GET /api/v1/accounts/:account_id/search/conversations?q=xxx&status=open&assignee_id=1
|
|
// Reference: Chatwoot conversations#index with filter params.
|
|
|
|
// @Summary Search conversations
|
|
// @Description Searches conversations by query string with advanced filtering (status, assignee, labels, date range)
|
|
// @Tags Search
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param account_id path uint true "Account ID"
|
|
// @Param q query string true "Search query string"
|
|
// @Param search_mode query string false "Search mode: ilike (substring) or trigram (fuzzy)" default(ilike)
|
|
// @Param status query string false "Conversation status filter (open,resolved,pending,snoozed)"
|
|
// @Param priority query string false "Conversation priority filter (none,low,medium,high,urgent)"
|
|
// @Param assignee_id query int false "Assignee agent ID filter"
|
|
// @Param team_id query int false "Team ID filter"
|
|
// @Param inbox_id query int false "Inbox ID filter"
|
|
// @Param labels query string false "Label filter (comma-separated)"
|
|
// @Param date_from query string false "Date range start (ISO 8601)"
|
|
// @Param date_to query string false "Date range end (ISO 8601)"
|
|
// @Param sort_by query string false "Sort field (created_at,last_activity_at,updated_at)" default(created_at)
|
|
// @Param sort_order query string false "Sort order (asc,desc)" default(desc)
|
|
// @Param page query int false "Page number" default(1)
|
|
// @Param per_page query int false "Ignored for Chatwoot parity; search results are fixed at 15 per page" default(15)
|
|
// @Success 200 {object} map[string]interface{}
|
|
// @Failure 400 {object} model.ErrorResponse
|
|
// @Failure 401 {object} model.ErrorResponse
|
|
// @Failure 500 {object} model.ErrorResponse
|
|
// @Security ApiKeyAuth
|
|
// @Router /api/v1/accounts/{account_id}/search/conversations [get]
|
|
func (h *SearchHandler) SearchConversations(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account id")
|
|
return
|
|
}
|
|
|
|
query := c.Query("q")
|
|
filter := parseChatwootSearchFilter(c, "conversation")
|
|
// Force type to conversations only
|
|
filter.Types = []search.SearchResultType{search.ResultTypeConversation}
|
|
|
|
results, total, svcErr := h.svc.SearchConversations(c.Request.Context(), accountID, query, &filter)
|
|
if svcErr != nil {
|
|
response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrValidation, "conversation search failed")
|
|
return
|
|
}
|
|
|
|
_ = total
|
|
c.JSON(http.StatusOK, gin.H{"payload": gin.H{"conversations": serializeSearchConversations(c.Request.Context(), h.db, results)}})
|
|
}
|
|
|
|
// SearchMessages performs a message-only search with advanced filters.
|
|
// GET /api/v1/accounts/:account_id/search/messages?q=xxx&message_type=incoming&private=false
|
|
// Reference: Chatwoot messages search — full text search on message content.
|
|
|
|
// @Summary Search messages
|
|
// @Description Searches messages by query string with advanced filtering (message type, sender type, content type, private)
|
|
// @Tags Search
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param account_id path uint true "Account ID"
|
|
// @Param q query string true "Search query string"
|
|
// @Param search_mode query string false "Search mode: ilike (substring) or trigram (fuzzy)" default(ilike)
|
|
// @Param message_type query string false "Message type filter (incoming,outgoing,activity)"
|
|
// @Param sender_type query string false "Sender type filter"
|
|
// @Param content_type query string false "Content type filter (text,input_email,card)"
|
|
// @Param private query bool false "Private message filter"
|
|
// @Param inbox_id query int false "Inbox ID filter"
|
|
// @Param date_from query string false "Date range start (ISO 8601)"
|
|
// @Param date_to query string false "Date range end (ISO 8601)"
|
|
// @Param sort_by query string false "Sort field (created_at,updated_at)" default(created_at)
|
|
// @Param sort_order query string false "Sort order (asc,desc)" default(desc)
|
|
// @Param page query int false "Page number" default(1)
|
|
// @Param per_page query int false "Ignored for Chatwoot parity; search results are fixed at 15 per page" default(15)
|
|
// @Success 200 {object} map[string]interface{}
|
|
// @Failure 400 {object} model.ErrorResponse
|
|
// @Failure 401 {object} model.ErrorResponse
|
|
// @Failure 500 {object} model.ErrorResponse
|
|
// @Security ApiKeyAuth
|
|
// @Router /api/v1/accounts/{account_id}/search/messages [get]
|
|
func (h *SearchHandler) SearchMessages(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account id")
|
|
return
|
|
}
|
|
|
|
query := c.Query("q")
|
|
filter := parseChatwootSearchFilter(c, "message")
|
|
// Force type to messages only
|
|
filter.Types = []search.SearchResultType{search.ResultTypeMessage}
|
|
|
|
results, total, svcErr := h.svc.SearchMessages(c.Request.Context(), accountID, query, &filter)
|
|
if svcErr != nil {
|
|
response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrValidation, "message search failed")
|
|
return
|
|
}
|
|
|
|
_ = total
|
|
c.JSON(http.StatusOK, gin.H{"payload": gin.H{"messages": serializeSearchMessages(c.Request.Context(), h.db, results)}})
|
|
}
|
|
|
|
// SearchContacts performs a contact-only search with advanced filters.
|
|
// GET /api/v1/accounts/:account_id/search/contacts?q=xxx&contact_source=email
|
|
// Reference: Chatwoot contacts#search — name, email, phone, identifier.
|
|
|
|
// @Summary Search contacts
|
|
// @Description Searches contacts by query string (name, email, phone, identifier) with advanced filtering
|
|
// @Tags Search
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param account_id path uint true "Account ID"
|
|
// @Param q query string true "Search query string"
|
|
// @Param search_mode query string false "Search mode: ilike (substring) or trigram (fuzzy)" default(ilike)
|
|
// @Param contact_source query string false "Contact source filter (email,phone,website,api)"
|
|
// @Param sort_by query string false "Sort field (created_at,updated_at,name)" default(created_at)
|
|
// @Param sort_order query string false "Sort order (asc,desc)" default(desc)
|
|
// @Param page query int false "Page number" default(1)
|
|
// @Param per_page query int false "Ignored for Chatwoot parity; search results are fixed at 15 per page" default(15)
|
|
// @Success 200 {object} map[string]interface{}
|
|
// @Failure 400 {object} model.ErrorResponse
|
|
// @Failure 401 {object} model.ErrorResponse
|
|
// @Failure 500 {object} model.ErrorResponse
|
|
// @Security ApiKeyAuth
|
|
// @Router /api/v1/accounts/{account_id}/search/contacts [get]
|
|
func (h *SearchHandler) SearchContacts(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account id")
|
|
return
|
|
}
|
|
|
|
query := c.Query("q")
|
|
filter := parseChatwootSearchFilter(c, "contact")
|
|
// Force type to contacts only
|
|
filter.Types = []search.SearchResultType{search.ResultTypeContact}
|
|
|
|
results, total, svcErr := h.svc.SearchResolvedContacts(c.Request.Context(), accountID, query, &filter)
|
|
if svcErr != nil {
|
|
response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrValidation, "contact search failed")
|
|
return
|
|
}
|
|
|
|
_ = total
|
|
c.JSON(http.StatusOK, gin.H{"payload": gin.H{"contacts": serializeSearchContacts(results)}})
|
|
}
|
|
|
|
// SearchArticles performs a knowledge base article-only search with advanced filters.
|
|
// GET /api/v1/accounts/:account_id/search/articles?q=xxx&portal_id=1&article_status=published&locale=en
|
|
// Reference: Chatwoot ArticlesController#search — full text search on article title, description, content.
|
|
|
|
// @Summary Search knowledge base articles
|
|
// @Description Searches knowledge base articles by query string (title, description, content) with portal, status, and locale filters
|
|
// @Tags Search
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param account_id path uint true "Account ID"
|
|
// @Param q query string true "Search query string"
|
|
// @Param search_mode query string false "Search mode: ilike (substring) or trigram (fuzzy)" default(ilike)
|
|
// @Param portal_id query int false "Portal ID filter"
|
|
// @Param article_status query string false "Article status filter (draft,published,archived)"
|
|
// @Param article_locale query string false "Article locale filter (en,es,fr,de,pt,etc)"
|
|
// @Param author_id query int false "Author ID filter"
|
|
// @Param sort_by query string false "Sort field (created_at,updated_at)" default(created_at)
|
|
// @Param sort_order query string false "Sort order (asc,desc)" default(desc)
|
|
// @Param page query int false "Page number" default(1)
|
|
// @Param per_page query int false "Ignored for Chatwoot parity; search results are fixed at 15 per page" default(15)
|
|
// @Success 200 {object} map[string]interface{}
|
|
// @Failure 400 {object} model.ErrorResponse
|
|
// @Failure 401 {object} model.ErrorResponse
|
|
// @Failure 500 {object} model.ErrorResponse
|
|
// @Security ApiKeyAuth
|
|
// @Router /api/v1/accounts/{account_id}/search/articles [get]
|
|
func (h *SearchHandler) SearchArticles(c *gin.Context) {
|
|
accountID, err := parseUintParam(c, "account_id")
|
|
if err != nil {
|
|
response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account id")
|
|
return
|
|
}
|
|
|
|
query := c.Query("q")
|
|
filter := parseChatwootSearchFilter(c, "article")
|
|
// Force type to articles only
|
|
filter.Types = []search.SearchResultType{search.ResultTypeArticle}
|
|
|
|
results, total, svcErr := h.svc.SearchArticles(c.Request.Context(), accountID, query, &filter)
|
|
if svcErr != nil {
|
|
response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrValidation, "article search failed")
|
|
return
|
|
}
|
|
|
|
_ = total
|
|
c.JSON(http.StatusOK, gin.H{"payload": gin.H{"articles": serializeSearchArticles(c.Request.Context(), h.db, results)}})
|
|
}
|
|
|
|
func serializeSearchPayload(ctx context.Context, db *gorm.DB, results []search.SearchResult) gin.H {
|
|
return gin.H{
|
|
"conversations": serializeSearchConversations(ctx, db, filterSearchResults(results, search.ResultTypeConversation)),
|
|
"contacts": serializeSearchContacts(filterSearchResults(results, search.ResultTypeContact)),
|
|
"messages": serializeSearchMessages(ctx, db, filterSearchResults(results, search.ResultTypeMessage)),
|
|
"articles": serializeSearchArticles(ctx, db, filterSearchResults(results, search.ResultTypeArticle)),
|
|
}
|
|
}
|
|
|
|
func parseChatwootSearchFilter(c *gin.Context, scope string) search.SearchFilter {
|
|
filter := search.ParseSearchFilter(c)
|
|
if userID := getUserID(c); userID != 0 {
|
|
filter.CurrentUserID = &userID
|
|
}
|
|
filter.PerPage = chatwootSearchPerPage
|
|
filter = sanitizeChatwootSearchFilter(filter, scope)
|
|
return filter
|
|
}
|
|
|
|
func sanitizeChatwootSearchFilter(filter search.SearchFilter, scope string) search.SearchFilter {
|
|
filter.Status = nil
|
|
filter.Priority = nil
|
|
filter.AssigneeID = nil
|
|
filter.TeamID = nil
|
|
filter.Labels = nil
|
|
filter.ContactSource = ""
|
|
filter.MessageType = ""
|
|
filter.ContentType = ""
|
|
filter.Private = nil
|
|
filter.PortalID = nil
|
|
filter.ArticleStatus = ""
|
|
filter.ArticleLocale = ""
|
|
if scope != "message" && scope != "global" {
|
|
filter.SenderType = ""
|
|
filter.SenderID = nil
|
|
filter.InboxID = nil
|
|
}
|
|
return filter
|
|
}
|
|
|
|
func filterSearchResults(results []search.SearchResult, resultType search.SearchResultType) []search.SearchResult {
|
|
filtered := make([]search.SearchResult, 0)
|
|
for _, result := range results {
|
|
if result.Type == resultType {
|
|
filtered = append(filtered, result)
|
|
}
|
|
}
|
|
return filtered
|
|
}
|
|
|
|
func serializeSearchConversations(ctx context.Context, db *gorm.DB, results []search.SearchResult) []map[string]any {
|
|
payload := make([]map[string]any, 0, len(results))
|
|
for _, result := range results {
|
|
payload = append(payload, serializeSearchConversation(ctx, db, result))
|
|
}
|
|
return payload
|
|
}
|
|
|
|
func serializeSearchConversation(ctx context.Context, db *gorm.DB, result search.SearchResult) map[string]any {
|
|
if conv, ok := result.Data.(model.Conversation); ok {
|
|
return serializeSearchConversationModel(ctx, db, &conv)
|
|
}
|
|
if conv, ok := result.Data.(*model.Conversation); ok && conv != nil {
|
|
return serializeSearchConversationModel(ctx, db, conv)
|
|
}
|
|
root := searchDataRoot(result)
|
|
data := nestedSearchDataFromRoot(root, "conversation")
|
|
return map[string]any{
|
|
"id": firstMapValue(data, "display_id", "id"),
|
|
"account_id": firstMapValue(data, "account_id"),
|
|
"created_at": unixFromMapValue(firstMapValue(data, "created_at", "created_at_ts")),
|
|
"additional_attributes": firstMapValue(data, "additional_attributes"),
|
|
"message": serializeSearchConversationMessageMap(ctx, db, firstNestedSearchData(root, data, "message")),
|
|
"contact": serializeSearchConversationContactMap(firstNestedSearchData(root, data, "contact")),
|
|
"inbox": serializeSearchConversationInboxMap(firstNestedSearchData(root, data, "inbox")),
|
|
"agent": serializeSearchConversationAgentMap(firstNestedSearchData(root, data, "agent", "assignee")),
|
|
}
|
|
}
|
|
|
|
func serializeSearchConversationModel(ctx context.Context, db *gorm.DB, conv *model.Conversation) map[string]any {
|
|
return map[string]any{
|
|
"id": conversationDisplayID(conv),
|
|
"account_id": conv.AccountID,
|
|
"created_at": conv.CreatedAt.Unix(),
|
|
"additional_attributes": jsonObject(conv.AdditionalAttributes),
|
|
"message": serializeSearchConversationMessageModel(ctx, db, conv),
|
|
"contact": serializeSearchConversationContactModel(conv),
|
|
"inbox": serializeSearchConversationInboxModel(conv),
|
|
"agent": serializeSearchConversationAgentModel(conv),
|
|
}
|
|
}
|
|
|
|
func serializeSearchConversationMessageModel(ctx context.Context, db *gorm.DB, conv *model.Conversation) map[string]any {
|
|
if len(conv.Messages) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
return serializeSearchMessageModel(ctx, db, &conv.Messages[0])
|
|
}
|
|
|
|
func serializeSearchConversationContactModel(conv *model.Conversation) map[string]any {
|
|
if conv.Contact != nil {
|
|
return serializeSearchContactModel(conv.Contact)
|
|
}
|
|
if conv.ContactID != 0 {
|
|
return map[string]any{"id": conv.ContactID}
|
|
}
|
|
return map[string]any{}
|
|
}
|
|
|
|
func serializeSearchConversationInboxModel(conv *model.Conversation) map[string]any {
|
|
if conv.Inbox != nil {
|
|
return map[string]any{
|
|
"id": conv.Inbox.ID,
|
|
"channel_id": conv.Inbox.ChannelID,
|
|
"name": conv.Inbox.Name,
|
|
"channel_type": conv.Inbox.ChannelType,
|
|
}
|
|
}
|
|
if conv.InboxID != 0 {
|
|
return map[string]any{"id": conv.InboxID, "channel_type": conv.ChannelType}
|
|
}
|
|
return map[string]any{}
|
|
}
|
|
|
|
func serializeSearchConversationAgentModel(conv *model.Conversation) map[string]any {
|
|
if conv.Assignee != nil {
|
|
return map[string]any{
|
|
"id": conv.Assignee.ID,
|
|
"available_name": nonEmpty(conv.Assignee.DisplayName, conv.Assignee.Name),
|
|
"email": conv.Assignee.Email,
|
|
"name": conv.Assignee.Name,
|
|
"role": nonEmpty(conv.Assignee.Role, "agent"),
|
|
}
|
|
}
|
|
return map[string]any{}
|
|
}
|
|
|
|
func serializeSearchConversationMessageMap(ctx context.Context, db *gorm.DB, data map[string]any) map[string]any {
|
|
if len(data) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
return serializeSearchMessage(ctx, db, search.SearchResult{Data: map[string]any{"message": data}})
|
|
}
|
|
|
|
func serializeSearchConversationContactMap(data map[string]any) map[string]any {
|
|
if len(data) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
return map[string]any{
|
|
"email": firstMapValue(data, "email"),
|
|
"id": firstMapValue(data, "id"),
|
|
"name": firstMapValue(data, "name"),
|
|
"phone_number": firstMapValue(data, "phone_number"),
|
|
"identifier": firstMapValue(data, "identifier"),
|
|
"additional_attributes": firstMapValue(data, "additional_attributes"),
|
|
"last_activity_at": unixFromMapValue(firstMapValue(data, "last_activity_at")),
|
|
}
|
|
}
|
|
|
|
func serializeSearchConversationInboxMap(data map[string]any) map[string]any {
|
|
if len(data) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
return map[string]any{
|
|
"id": firstMapValue(data, "id"),
|
|
"channel_id": firstMapValue(data, "channel_id"),
|
|
"name": firstMapValue(data, "name"),
|
|
"channel_type": firstMapValue(data, "channel_type"),
|
|
}
|
|
}
|
|
|
|
func serializeSearchConversationAgentMap(data map[string]any) map[string]any {
|
|
if len(data) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
return map[string]any{
|
|
"id": firstMapValue(data, "id"),
|
|
"available_name": firstMapValue(data, "available_name", "display_name", "name"),
|
|
"email": firstMapValue(data, "email"),
|
|
"name": firstMapValue(data, "name"),
|
|
"role": firstMapValue(data, "role"),
|
|
}
|
|
}
|
|
|
|
func serializeSearchContacts(results []search.SearchResult) []map[string]any {
|
|
payload := make([]map[string]any, 0, len(results))
|
|
for _, result := range results {
|
|
payload = append(payload, serializeSearchContact(result))
|
|
}
|
|
return payload
|
|
}
|
|
|
|
func serializeSearchContact(result search.SearchResult) map[string]any {
|
|
if contact, ok := result.Data.(model.Contact); ok {
|
|
return serializeSearchContactModel(&contact)
|
|
}
|
|
if contact, ok := result.Data.(*model.Contact); ok && contact != nil {
|
|
return serializeSearchContactModel(contact)
|
|
}
|
|
data := nestedSearchData(result, "contact")
|
|
return map[string]any{
|
|
"email": firstMapValue(data, "email"),
|
|
"id": firstMapValue(data, "id"),
|
|
"name": firstMapValue(data, "name"),
|
|
"phone_number": firstMapValue(data, "phone_number"),
|
|
"identifier": firstMapValue(data, "identifier"),
|
|
"additional_attributes": firstMapValue(data, "additional_attributes"),
|
|
"last_activity_at": unixFromMapValue(firstMapValue(data, "last_activity_at")),
|
|
}
|
|
}
|
|
|
|
func serializeSearchContactModel(contact *model.Contact) map[string]any {
|
|
return map[string]any{
|
|
"email": contact.Email,
|
|
"id": contact.ID,
|
|
"name": contact.Name,
|
|
"phone_number": contact.PhoneNumber,
|
|
"identifier": contact.Identifier,
|
|
"additional_attributes": jsonObject(contact.AdditionalAttributes),
|
|
"last_activity_at": int64Value(contact.LastActivityAt),
|
|
}
|
|
}
|
|
|
|
func serializeSearchMessages(ctx context.Context, db *gorm.DB, results []search.SearchResult) []map[string]any {
|
|
payload := make([]map[string]any, 0, len(results))
|
|
for _, result := range results {
|
|
payload = append(payload, serializeSearchMessage(ctx, db, result))
|
|
}
|
|
return payload
|
|
}
|
|
|
|
func serializeSearchMessage(ctx context.Context, db *gorm.DB, result search.SearchResult) map[string]any {
|
|
if message, ok := result.Data.(model.Message); ok {
|
|
return serializeSearchMessageModel(ctx, db, &message)
|
|
}
|
|
if message, ok := result.Data.(*model.Message); ok && message != nil {
|
|
return serializeSearchMessageModel(ctx, db, message)
|
|
}
|
|
data := nestedSearchData(result, "message")
|
|
if db != nil {
|
|
if payload, ok := loadSearchMessagePayload(ctx, db, uintFromAny(firstMapValue(data, "id")), result.AccountID); ok {
|
|
return payload
|
|
}
|
|
}
|
|
return omitNilSearchMessageFields(map[string]any{
|
|
"id": firstMapValue(data, "id"),
|
|
"content": firstMapValue(data, "content"),
|
|
"account_id": firstMapValue(data, "account_id"),
|
|
"inbox_id": firstMapValue(data, "inbox_id"),
|
|
"conversation_id": firstMapValue(data, "conversation_id"),
|
|
"message_type": normalizeSearchMessageType(firstMapValue(data, "message_type")),
|
|
"content_type": firstMapValue(data, "content_type"),
|
|
"status": firstMapValue(data, "status"),
|
|
"content_attributes": firstMapValue(data, "content_attributes"),
|
|
"created_at": unixFromMapValue(firstMapValue(data, "created_at", "created_at_ts")),
|
|
"private": firstMapValue(data, "private"),
|
|
"source_id": firstMapValue(data, "source_id"),
|
|
"echo_id": firstMapValue(data, "echo_id"),
|
|
"sender": firstMapValue(data, "sender"),
|
|
"attachments": firstMapValue(data, "attachments"),
|
|
})
|
|
}
|
|
|
|
func normalizeSearchMessageType(value any) any {
|
|
s, ok := value.(string)
|
|
if !ok {
|
|
return value
|
|
}
|
|
if strings.TrimSpace(s) == "" {
|
|
return value
|
|
}
|
|
return messageTypeValue(s)
|
|
}
|
|
|
|
func serializeSearchMessageModel(ctx context.Context, db *gorm.DB, message *model.Message) map[string]any {
|
|
if db != nil {
|
|
if payload, ok := loadSearchMessagePayload(ctx, db, message.ID, message.AccountID); ok {
|
|
return payload
|
|
}
|
|
}
|
|
return omitNilSearchMessageFields(map[string]any{
|
|
"id": message.ID,
|
|
"content": message.Content,
|
|
"account_id": message.AccountID,
|
|
"inbox_id": message.InboxID,
|
|
"conversation_id": message.ConversationID,
|
|
"message_type": messageTypeValue(message.MessageType),
|
|
"content_type": nonEmpty(message.ContentType, "text"),
|
|
"status": nonEmpty(message.Status, "sent"),
|
|
"content_attributes": jsonObject(message.ContentAttributes),
|
|
"created_at": message.CreatedAt.Unix(),
|
|
"private": message.Private,
|
|
"source_id": message.SourceID,
|
|
"echo_id": message.EchoID,
|
|
})
|
|
}
|
|
|
|
func loadSearchMessagePayload(ctx context.Context, db *gorm.DB, messageID uint, accountID uint) (map[string]any, bool) {
|
|
if db == nil || messageID == 0 {
|
|
return nil, false
|
|
}
|
|
var message model.Message
|
|
q := db.WithContext(ctx).Where("id = ?", messageID)
|
|
if accountID != 0 {
|
|
q = q.Where("account_id = ?", accountID)
|
|
}
|
|
if err := q.First(&message).Error; err != nil {
|
|
return nil, false
|
|
}
|
|
var conversation model.Conversation
|
|
if err := db.WithContext(ctx).
|
|
Where("id = ? AND account_id = ?", message.ConversationID, message.AccountID).
|
|
First(&conversation).Error; err != nil {
|
|
return chatwootMessagePayloadMap(serializeMessage(ctx, db, &message, nil)), true
|
|
}
|
|
return chatwootMessagePayloadMap(serializeMessage(ctx, db, &message, &conversation)), true
|
|
}
|
|
|
|
func chatwootMessagePayloadMap(payload chatwootMessagePayload) map[string]any {
|
|
data := map[string]any{
|
|
"id": payload.ID,
|
|
"content": payload.Content,
|
|
"inbox_id": payload.InboxID,
|
|
"account_id": payload.AccountID,
|
|
"conversation_id": payload.ConversationID,
|
|
"message_type": payload.MessageType,
|
|
"content_type": payload.ContentType,
|
|
"status": payload.Status,
|
|
"content_attributes": payload.ContentAttributes,
|
|
"created_at": payload.CreatedAt,
|
|
"private": payload.Private,
|
|
"source_id": payload.SourceID,
|
|
}
|
|
if payload.EchoID != "" {
|
|
data["echo_id"] = payload.EchoID
|
|
}
|
|
if len(payload.Sender) > 0 {
|
|
data["sender"] = payload.Sender
|
|
}
|
|
if len(payload.Attachments) > 0 {
|
|
data["attachments"] = payload.Attachments
|
|
}
|
|
return data
|
|
}
|
|
|
|
func omitNilSearchMessageFields(data map[string]any) map[string]any {
|
|
for _, key := range []string{"echo_id", "sender", "attachments"} {
|
|
if data[key] == nil || data[key] == "" {
|
|
delete(data, key)
|
|
}
|
|
}
|
|
return data
|
|
}
|
|
|
|
func serializeSearchArticles(ctx context.Context, db *gorm.DB, results []search.SearchResult) []map[string]any {
|
|
payload := make([]map[string]any, 0, len(results))
|
|
for _, result := range results {
|
|
payload = append(payload, serializeSearchArticle(ctx, db, result))
|
|
}
|
|
return payload
|
|
}
|
|
|
|
func serializeSearchArticle(ctx context.Context, db *gorm.DB, result search.SearchResult) map[string]any {
|
|
if article, ok := result.Data.(model.Article); ok {
|
|
return serializeSearchArticleModel(ctx, db, &article)
|
|
}
|
|
if article, ok := result.Data.(*model.Article); ok && article != nil {
|
|
return serializeSearchArticleModel(ctx, db, article)
|
|
}
|
|
data := nestedSearchData(result, "article")
|
|
if db != nil {
|
|
if payload, ok := loadSearchArticlePayload(ctx, db, uintFromAny(firstMapValue(data, "id")), result.AccountID); ok {
|
|
return payload
|
|
}
|
|
}
|
|
return map[string]any{
|
|
"id": firstMapValue(data, "id"),
|
|
"title": firstMapValue(data, "title"),
|
|
"locale": firstMapValue(data, "locale"),
|
|
"content": firstMapValue(data, "content"),
|
|
"slug": firstMapValue(data, "slug"),
|
|
"portal_slug": firstMapValue(data, "portal_slug"),
|
|
"account_id": firstMapValue(data, "account_id"),
|
|
"category_name": firstMapValue(data, "category_name"),
|
|
"status": firstMapValue(data, "status"),
|
|
"updated_at": unixFromMapValue(firstMapValue(data, "updated_at", "updated_at_ts")),
|
|
}
|
|
}
|
|
|
|
func serializeSearchArticleModel(ctx context.Context, db *gorm.DB, article *model.Article) map[string]any {
|
|
if db != nil {
|
|
if payload, ok := loadSearchArticlePayload(ctx, db, article.ID, article.AccountID); ok {
|
|
return payload
|
|
}
|
|
}
|
|
portalSlug := ""
|
|
if article.Portal.Slug != "" {
|
|
portalSlug = article.Portal.Slug
|
|
}
|
|
categoryName := ""
|
|
if article.Category != nil && article.Category.Name != "" {
|
|
categoryName = article.Category.Name
|
|
}
|
|
return map[string]any{
|
|
"id": article.ID,
|
|
"title": article.Title,
|
|
"locale": article.Locale,
|
|
"content": article.Content,
|
|
"slug": article.Slug,
|
|
"portal_slug": portalSlug,
|
|
"account_id": article.AccountID,
|
|
"category_name": categoryName,
|
|
"status": article.Status,
|
|
"updated_at": article.UpdatedAt.Unix(),
|
|
}
|
|
}
|
|
|
|
func loadSearchArticlePayload(ctx context.Context, db *gorm.DB, articleID uint, accountID uint) (map[string]any, bool) {
|
|
if db == nil || articleID == 0 {
|
|
return nil, false
|
|
}
|
|
var article model.Article
|
|
q := db.WithContext(ctx).Preload("Portal").Preload("Category").Where("id = ?", articleID)
|
|
if accountID != 0 {
|
|
q = q.Where("account_id = ?", accountID)
|
|
}
|
|
if err := q.First(&article).Error; err != nil {
|
|
return nil, false
|
|
}
|
|
return serializeSearchArticleModel(ctx, nil, &article), true
|
|
}
|
|
|
|
func nestedSearchData(result search.SearchResult, key string) map[string]any {
|
|
return nestedSearchDataFromRoot(searchDataRoot(result), key)
|
|
}
|
|
|
|
func searchDataRoot(result search.SearchResult) map[string]any {
|
|
root, ok := anyMap(result.Data)
|
|
if !ok {
|
|
return map[string]any{}
|
|
}
|
|
if data, ok := anyMap(root["data"]); ok {
|
|
return data
|
|
}
|
|
return root
|
|
}
|
|
|
|
func nestedSearchDataFromRoot(root map[string]any, key string) map[string]any {
|
|
if nested, ok := anyMap(root[key]); ok {
|
|
return nested
|
|
}
|
|
if data, ok := anyMap(root["data"]); ok {
|
|
if nested, ok := anyMap(data[key]); ok {
|
|
return nested
|
|
}
|
|
return data
|
|
}
|
|
return root
|
|
}
|
|
|
|
func firstNestedSearchData(root map[string]any, fallback map[string]any, keys ...string) map[string]any {
|
|
for _, key := range keys {
|
|
if nested, ok := anyMap(root[key]); ok {
|
|
return nested
|
|
}
|
|
if nested, ok := anyMap(fallback[key]); ok {
|
|
return nested
|
|
}
|
|
}
|
|
return map[string]any{}
|
|
}
|
|
|
|
func anyMap(value any) (map[string]any, bool) {
|
|
switch typed := value.(type) {
|
|
case map[string]any:
|
|
return typed, true
|
|
case gin.H:
|
|
return map[string]any(typed), true
|
|
default:
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
func firstMapValue(data map[string]any, keys ...string) any {
|
|
for _, key := range keys {
|
|
if value, ok := data[key]; ok {
|
|
return value
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func unixFromMapValue(value any) any {
|
|
switch typed := value.(type) {
|
|
case float64:
|
|
return int64(typed)
|
|
case int64:
|
|
return typed
|
|
case int:
|
|
return int64(typed)
|
|
case uint:
|
|
return int64(typed)
|
|
default:
|
|
return typed
|
|
}
|
|
}
|
|
|
|
func uintFromAny(value any) uint {
|
|
switch typed := value.(type) {
|
|
case uint:
|
|
return typed
|
|
case int:
|
|
if typed > 0 {
|
|
return uint(typed)
|
|
}
|
|
case int64:
|
|
if typed > 0 {
|
|
return uint(typed)
|
|
}
|
|
case float64:
|
|
if typed > 0 {
|
|
return uint(typed)
|
|
}
|
|
}
|
|
return 0
|
|
}
|