gobha
be67feaa8e
Co-authored-by: gobha <jasafpro@gmail.com> Co-committed-by: gobha <jasafpro@gmail.com>
642 lines
20 KiB
Go
642 lines
20 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"chat-switchboard/database"
|
|
"chat-switchboard/models"
|
|
"chat-switchboard/store"
|
|
)
|
|
|
|
// ── Request / Response types ────────────────
|
|
|
|
type createChannelRequest struct {
|
|
Title string `json:"title" binding:"required,max=500"`
|
|
Type string `json:"type,omitempty"` // direct (default), dm, group, channel, workflow
|
|
Description string `json:"description,omitempty"`
|
|
Model string `json:"model,omitempty"`
|
|
SystemPrompt string `json:"system_prompt,omitempty"`
|
|
ProviderConfigID *string `json:"provider_config_id,omitempty"`
|
|
Folder string `json:"folder,omitempty"`
|
|
FolderID *string `json:"folder_id,omitempty"`
|
|
Tags []string `json:"tags,omitempty"`
|
|
// v0.23.2: DM creation
|
|
Participants []string `json:"participants,omitempty"` // user IDs for DM (exactly 1 other user)
|
|
AiMode string `json:"ai_mode,omitempty"` // auto (default), mention_only, off
|
|
}
|
|
|
|
type updateChannelRequest struct {
|
|
Title *string `json:"title,omitempty"`
|
|
Description *string `json:"description,omitempty"`
|
|
Model *string `json:"model,omitempty"`
|
|
SystemPrompt *string `json:"system_prompt,omitempty"`
|
|
ProviderConfigID *string `json:"provider_config_id,omitempty"`
|
|
IsArchived *bool `json:"is_archived,omitempty"`
|
|
IsPinned *bool `json:"is_pinned,omitempty"`
|
|
Folder *string `json:"folder,omitempty"`
|
|
FolderID *string `json:"folder_id,omitempty"`
|
|
Tags []string `json:"tags,omitempty"`
|
|
Settings *json.RawMessage `json:"settings,omitempty"` // JSONB merge into existing settings
|
|
WorkspaceID *string `json:"workspace_id,omitempty"` // bind workspace (v0.21.5)
|
|
AiMode *string `json:"ai_mode,omitempty"` // v0.23.2: auto, mention_only, off
|
|
Topic *string `json:"topic,omitempty"` // v0.23.2: channel topic
|
|
}
|
|
|
|
type channelResponse struct {
|
|
ID string `json:"id"`
|
|
UserID string `json:"user_id"`
|
|
Title string `json:"title"`
|
|
Type string `json:"type"`
|
|
AiMode string `json:"ai_mode,omitempty"`
|
|
Topic *string `json:"topic,omitempty"`
|
|
Description *string `json:"description"`
|
|
Model *string `json:"model"`
|
|
ProviderConfigID *string `json:"provider_config_id"`
|
|
SystemPrompt *string `json:"system_prompt"`
|
|
IsArchived bool `json:"is_archived"`
|
|
IsPinned bool `json:"is_pinned"`
|
|
Folder *string `json:"folder"`
|
|
FolderID *string `json:"folder_id,omitempty"`
|
|
ProjectID *string `json:"project_id,omitempty"`
|
|
WorkspaceID *string `json:"workspace_id,omitempty"`
|
|
Tags []string `json:"tags"`
|
|
Settings json.RawMessage `json:"settings,omitempty"`
|
|
MessageCount int `json:"message_count"`
|
|
UnreadCount int `json:"unread_count,omitempty"`
|
|
CreatedAt string `json:"created_at"`
|
|
UpdatedAt string `json:"updated_at"`
|
|
}
|
|
|
|
type paginatedResponse struct {
|
|
Data interface{} `json:"data"`
|
|
Page int `json:"page"`
|
|
PerPage int `json:"per_page"`
|
|
Total int `json:"total"`
|
|
TotalPages int `json:"total_pages"`
|
|
}
|
|
|
|
// ChannelHandler holds dependencies for channel endpoints.
|
|
type ChannelHandler struct {
|
|
stores store.Stores
|
|
}
|
|
|
|
// NewChannelHandler creates a new channel handler.
|
|
func NewChannelHandler(stores store.Stores) *ChannelHandler {
|
|
return &ChannelHandler{stores: stores}
|
|
}
|
|
|
|
// channelDeleteHook is called after a channel is successfully deleted.
|
|
// Set at startup by SetChannelDeleteHook to clean up storage files.
|
|
var channelDeleteHook func(channelID string)
|
|
|
|
// SetChannelDeleteHook registers a callback invoked after channel deletion.
|
|
// Used to clean up channel files on the storage backend.
|
|
func SetChannelDeleteHook(fn func(channelID string)) {
|
|
channelDeleteHook = fn
|
|
}
|
|
|
|
// ── Helpers ─────────────────────────────────
|
|
|
|
// getUserID extracts the authenticated user's ID from context.
|
|
func getUserID(c *gin.Context) string {
|
|
uid, _ := c.Get("user_id")
|
|
s, _ := uid.(string)
|
|
return s
|
|
}
|
|
|
|
// isSessionAuth returns true if the request is from a session participant (v0.24.3).
|
|
func isSessionAuth(c *gin.Context) bool {
|
|
return c.GetString("auth_type") == "session"
|
|
}
|
|
|
|
// sessionCanAccessChannel validates that a session participant is authorized
|
|
// for the given channel.
|
|
func sessionCanAccessChannel(c *gin.Context, channelID string) bool {
|
|
if !isSessionAuth(c) {
|
|
return false
|
|
}
|
|
return c.GetString("channel_id") == channelID
|
|
}
|
|
|
|
// parsePagination reads page and per_page from query params with defaults.
|
|
func parsePagination(c *gin.Context) (page, perPage, offset int) {
|
|
page, _ = strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
perPage, _ = strconv.Atoi(c.DefaultQuery("per_page", "50"))
|
|
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if perPage < 1 {
|
|
perPage = 50
|
|
}
|
|
if perPage > 100 {
|
|
perPage = 100
|
|
}
|
|
offset = (page - 1) * perPage
|
|
return
|
|
}
|
|
|
|
// listItemToResponse converts a store.ChannelListItem to a handler response.
|
|
func listItemToResponse(item store.ChannelListItem) channelResponse {
|
|
tags := item.Tags
|
|
if tags == nil {
|
|
tags = []string{}
|
|
}
|
|
return channelResponse{
|
|
ID: item.ID,
|
|
UserID: item.UserID,
|
|
Title: item.Title,
|
|
Type: item.Type,
|
|
AiMode: item.AiMode,
|
|
Topic: item.Topic,
|
|
Description: item.Description,
|
|
Model: item.Model,
|
|
ProviderConfigID: item.ProviderConfigID,
|
|
SystemPrompt: item.SystemPrompt,
|
|
IsArchived: item.IsArchived,
|
|
IsPinned: item.IsPinned,
|
|
Folder: item.Folder,
|
|
FolderID: item.FolderID,
|
|
ProjectID: item.ProjectID,
|
|
WorkspaceID: item.WorkspaceID,
|
|
Tags: tags,
|
|
Settings: item.Settings,
|
|
MessageCount: item.MessageCount,
|
|
UnreadCount: item.UnreadCount,
|
|
CreatedAt: item.CreatedAt,
|
|
UpdatedAt: item.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
// ── List Channels ───────────────────────────
|
|
|
|
func (h *ChannelHandler) ListChannels(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
page, perPage, offset := parsePagination(c)
|
|
|
|
// Optional filters
|
|
archived := c.DefaultQuery("archived", "false")
|
|
|
|
var channelTypes []string
|
|
if raw := c.Query("types"); raw != "" {
|
|
for _, t := range strings.Split(raw, ",") {
|
|
t = strings.TrimSpace(t)
|
|
if t != "" {
|
|
channelTypes = append(channelTypes, t)
|
|
}
|
|
}
|
|
}
|
|
if len(channelTypes) == 0 {
|
|
if ct := c.DefaultQuery("type", ""); ct != "" {
|
|
channelTypes = []string{ct}
|
|
}
|
|
}
|
|
|
|
filter := store.ChannelListFilter{
|
|
ListOptions: store.ListOptions{Limit: perPage, Offset: offset},
|
|
Archived: archived == "true",
|
|
Types: channelTypes,
|
|
Folder: c.Query("folder"),
|
|
FolderID: c.Query("folder_id"),
|
|
Search: strings.TrimSpace(c.Query("search")),
|
|
ProjectID: c.Query("project_id"),
|
|
}
|
|
|
|
items, total, err := h.stores.Channels.ListFiltered(c.Request.Context(), userID, filter)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list channels"})
|
|
return
|
|
}
|
|
|
|
channels := make([]channelResponse, 0, len(items))
|
|
for _, item := range items {
|
|
channels = append(channels, listItemToResponse(item))
|
|
}
|
|
|
|
// Resolve DM titles: show the other participant's name, not the creator's label
|
|
resolveDMTitles(c.Request.Context(), channels, userID)
|
|
|
|
SafeJSON(c, http.StatusOK, paginatedResponse{
|
|
Data: channels,
|
|
Page: page,
|
|
PerPage: perPage,
|
|
Total: total,
|
|
TotalPages: int(math.Ceil(float64(total) / float64(perPage))),
|
|
})
|
|
}
|
|
|
|
// ── Create Channel ──────────────────────────
|
|
|
|
func (h *ChannelHandler) CreateChannel(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
|
|
var req createChannelRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
if req.Tags == nil {
|
|
req.Tags = []string{}
|
|
}
|
|
|
|
// Default type is "direct" (1:1 AI chat)
|
|
channelType := req.Type
|
|
if channelType == "" {
|
|
channelType = "direct"
|
|
}
|
|
|
|
// Default ai_mode: mention_only for DMs, auto for everything else
|
|
aiMode := req.AiMode
|
|
if aiMode == "" {
|
|
if channelType == "dm" {
|
|
aiMode = "mention_only"
|
|
} else {
|
|
aiMode = "auto"
|
|
}
|
|
}
|
|
|
|
ctx := c.Request.Context()
|
|
|
|
// ── DM dedup: check for existing DM between these two users ──
|
|
if channelType == "dm" && len(req.Participants) == 1 {
|
|
otherUserID := req.Participants[0]
|
|
if otherUserID == userID {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "cannot create DM with yourself"})
|
|
return
|
|
}
|
|
|
|
existingID, _ := h.stores.Channels.FindExistingDM(ctx, userID, otherUserID)
|
|
if existingID != "" {
|
|
// Return existing channel instead of creating duplicate
|
|
item, err := h.stores.Channels.GetForUser(ctx, existingID, userID)
|
|
if err == nil {
|
|
SafeJSON(c, http.StatusOK, listItemToResponse(*item)) // 200, not 201 — existing resource
|
|
return
|
|
}
|
|
// If read fails, fall through and create new (shouldn't happen)
|
|
}
|
|
}
|
|
|
|
// Build channel model
|
|
ch := &models.Channel{
|
|
UserID: userID,
|
|
Title: req.Title,
|
|
Type: channelType,
|
|
Description: req.Description,
|
|
Model: req.Model,
|
|
SystemPrompt: req.SystemPrompt,
|
|
ProviderConfigID: req.ProviderConfigID,
|
|
FolderID: req.FolderID,
|
|
}
|
|
|
|
dmPartners := []string{}
|
|
if channelType == "dm" {
|
|
dmPartners = req.Participants
|
|
}
|
|
|
|
defaultConfigID := ""
|
|
if req.ProviderConfigID != nil {
|
|
defaultConfigID = *req.ProviderConfigID
|
|
}
|
|
|
|
if err := h.stores.Channels.CreateFull(ctx, ch, req.Folder, req.Tags, aiMode,
|
|
userID, dmPartners, req.Model, defaultConfigID); err != nil {
|
|
log.Printf("[channels] CreateFull error: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create channel"})
|
|
return
|
|
}
|
|
|
|
// Fetch full response with message count
|
|
item, err := h.stores.Channels.GetForUser(ctx, ch.ID, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to read created channel"})
|
|
return
|
|
}
|
|
|
|
SafeJSON(c, http.StatusCreated, listItemToResponse(*item))
|
|
}
|
|
|
|
// ── Get Channel ─────────────────────────────
|
|
|
|
func (h *ChannelHandler) GetChannel(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
channelID := c.Param("id")
|
|
|
|
item, err := h.stores.Channels.GetForUser(c.Request.Context(), channelID, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
|
|
return
|
|
}
|
|
|
|
SafeJSON(c, http.StatusOK, listItemToResponse(*item))
|
|
}
|
|
|
|
// ── Update Channel ──────────────────────────
|
|
|
|
func (h *ChannelHandler) UpdateChannel(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
channelID := c.Param("id")
|
|
ctx := c.Request.Context()
|
|
|
|
var req updateChannelRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Verify ownership (participants can only move to folder)
|
|
owns, err := h.stores.Channels.UserOwns(ctx, channelID, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
|
|
return
|
|
}
|
|
if !owns {
|
|
// Participants may move channels to their own folders
|
|
folderOnly := req.FolderID != nil && req.Title == nil && req.Description == nil &&
|
|
req.Model == nil && req.SystemPrompt == nil && req.ProviderConfigID == nil &&
|
|
req.IsArchived == nil && req.IsPinned == nil && req.Folder == nil &&
|
|
req.Tags == nil && req.WorkspaceID == nil && req.AiMode == nil &&
|
|
req.Topic == nil && req.Settings == nil
|
|
if !folderOnly {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "not your channel"})
|
|
return
|
|
}
|
|
// Verify they are a participant
|
|
canAccess, _ := h.stores.Channels.UserCanAccess(ctx, channelID, userID)
|
|
if !canAccess {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "not your channel"})
|
|
return
|
|
}
|
|
}
|
|
|
|
// Build fields map for store.Update
|
|
fields := map[string]interface{}{}
|
|
|
|
if req.Title != nil {
|
|
fields["title"] = *req.Title
|
|
}
|
|
if req.Description != nil {
|
|
fields["description"] = *req.Description
|
|
}
|
|
if req.Model != nil {
|
|
fields["model"] = *req.Model
|
|
}
|
|
if req.SystemPrompt != nil {
|
|
fields["system_prompt"] = *req.SystemPrompt
|
|
}
|
|
if req.ProviderConfigID != nil {
|
|
if *req.ProviderConfigID == "" {
|
|
fields["provider_config_id"] = nil
|
|
} else {
|
|
fields["provider_config_id"] = *req.ProviderConfigID
|
|
}
|
|
}
|
|
if req.IsArchived != nil {
|
|
fields["is_archived"] = *req.IsArchived
|
|
}
|
|
if req.IsPinned != nil {
|
|
fields["is_pinned"] = *req.IsPinned
|
|
}
|
|
if req.Folder != nil {
|
|
fields["folder"] = *req.Folder
|
|
}
|
|
if req.FolderID != nil {
|
|
if *req.FolderID == "" {
|
|
fields["folder_id"] = nil // unbind from folder
|
|
} else {
|
|
fields["folder_id"] = *req.FolderID
|
|
}
|
|
}
|
|
if req.Tags != nil {
|
|
fields["tags"] = req.Tags
|
|
}
|
|
if req.WorkspaceID != nil {
|
|
if *req.WorkspaceID == "" {
|
|
fields["workspace_id"] = nil // unbind
|
|
} else {
|
|
fields["workspace_id"] = *req.WorkspaceID
|
|
}
|
|
}
|
|
if req.AiMode != nil {
|
|
mode := *req.AiMode
|
|
if mode != "auto" && mode != "mention_only" && mode != "off" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "ai_mode must be auto, mention_only, or off"})
|
|
return
|
|
}
|
|
fields["ai_mode"] = mode
|
|
}
|
|
if req.Topic != nil {
|
|
fields["topic"] = *req.Topic
|
|
}
|
|
|
|
hasFields := len(fields) > 0
|
|
hasSettings := req.Settings != nil
|
|
|
|
if !hasFields && !hasSettings {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "no fields to update"})
|
|
return
|
|
}
|
|
|
|
if hasSettings {
|
|
if !json.Valid([]byte(*req.Settings)) {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "settings must be valid JSON"})
|
|
return
|
|
}
|
|
}
|
|
|
|
if hasFields {
|
|
if err := h.stores.Channels.Update(ctx, channelID, fields); err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update channel"})
|
|
return
|
|
}
|
|
}
|
|
|
|
if hasSettings {
|
|
if err := h.stores.Channels.MergeSettings(ctx, channelID, json.RawMessage(*req.Settings)); err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update settings"})
|
|
return
|
|
}
|
|
}
|
|
|
|
// Return updated channel
|
|
h.GetChannel(c)
|
|
}
|
|
|
|
// ── Delete Channel ──────────────────────────
|
|
|
|
func (h *ChannelHandler) DeleteChannel(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
channelID := c.Param("id")
|
|
ctx := c.Request.Context()
|
|
|
|
// Check ownership first (without deleting)
|
|
owns, err := h.stores.Channels.UserOwns(ctx, channelID, userID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
|
|
return
|
|
}
|
|
if !owns {
|
|
// Not the owner — if participant, leave the channel instead of deleting.
|
|
res, _ := database.DB.ExecContext(ctx, database.Q(`
|
|
DELETE FROM channel_participants
|
|
WHERE channel_id = $1 AND participant_type = 'user' AND participant_id = $2
|
|
`), channelID, userID)
|
|
if rows, _ := res.RowsAffected(); rows > 0 {
|
|
c.JSON(http.StatusOK, gin.H{"message": "left channel"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
|
|
return
|
|
}
|
|
|
|
// Check if retention policy applies (global/team provider + TTL > 0)
|
|
if h.shouldRetain(ctx, channelID) {
|
|
ttl := h.retentionTTL(ctx)
|
|
purgeAfter := time.Now().Add(time.Duration(ttl) * 24 * time.Hour)
|
|
if err := h.stores.Channels.ArchiveForRetention(ctx, channelID, purgeAfter); err != nil {
|
|
log.Printf("[retention] ArchiveForRetention(%s) error: %v", channelID, err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to archive channel"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"message": "channel archived for retention",
|
|
"purge_after": purgeAfter.UTC().Format("2006-01-02T15:04:05Z"),
|
|
})
|
|
return
|
|
}
|
|
|
|
// Exempt — hard delete
|
|
n, err := h.stores.Channels.DeleteByOwner(ctx, channelID, userID)
|
|
if err != nil || n == 0 {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete channel"})
|
|
return
|
|
}
|
|
|
|
if channelDeleteHook != nil {
|
|
go channelDeleteHook(channelID)
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "channel deleted"})
|
|
}
|
|
|
|
// shouldRetain returns true if a channel uses a global or team provider
|
|
// and the retention TTL is configured (> 0).
|
|
func (h *ChannelHandler) shouldRetain(ctx context.Context, channelID string) bool {
|
|
ttl := h.retentionTTL(ctx)
|
|
if ttl <= 0 {
|
|
return false
|
|
}
|
|
|
|
// Only BYOK (personal) provider channels are exempt.
|
|
// All others — global, team, or no explicit provider — follow retention.
|
|
var providerConfigID *string
|
|
_ = database.DB.QueryRowContext(ctx, database.Q(`
|
|
SELECT provider_config_id FROM channels WHERE id = $1
|
|
`), channelID).Scan(&providerConfigID)
|
|
|
|
if providerConfigID == nil || *providerConfigID == "" {
|
|
return true // no explicit provider → defaults to global → retain
|
|
}
|
|
|
|
cfg, err := h.stores.Providers.GetByID(ctx, *providerConfigID)
|
|
if err != nil {
|
|
return true // provider deleted (FK SET NULL already handled above) → retain
|
|
}
|
|
|
|
return cfg.Scope != models.ScopePersonal
|
|
}
|
|
|
|
// retentionTTL reads the configured retention TTL in days from global settings.
|
|
func (h *ChannelHandler) retentionTTL(ctx context.Context) int {
|
|
cfg, err := h.stores.GlobalConfig.Get(ctx, "retention_ttl_days")
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
if v, ok := cfg["value"].(float64); ok {
|
|
return int(v)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// ── Mark Read (v0.23.2) ───────────────────────
|
|
|
|
func (h *ChannelHandler) MarkRead(c *gin.Context) {
|
|
userID := getUserID(c)
|
|
channelID := c.Param("id")
|
|
|
|
err := h.stores.Channels.MarkRead(c.Request.Context(), channelID, userID)
|
|
if err != nil {
|
|
// Participant row may not exist for legacy direct chats — that's OK
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"ok": true})
|
|
}
|
|
|
|
// ── DM Title Resolution ──────────────────────
|
|
|
|
// resolveDMTitles replaces DM channel titles with the other participant's
|
|
// display name so each user sees "DM <other_person>" instead of the
|
|
// creator's original label.
|
|
func resolveDMTitles(ctx context.Context, channels []channelResponse, viewerID string) {
|
|
// Collect DM channel IDs
|
|
var dmIDs []string
|
|
dmIdx := map[string]int{} // channel_id → index in channels slice
|
|
for i, ch := range channels {
|
|
if ch.Type == "dm" {
|
|
dmIDs = append(dmIDs, ch.ID)
|
|
dmIdx[ch.ID] = i
|
|
}
|
|
}
|
|
if len(dmIDs) == 0 {
|
|
return
|
|
}
|
|
|
|
// Query: for each DM, get the OTHER participant's display name
|
|
// Uses channel_participants to find the peer, then joins users for name
|
|
placeholders := make([]string, len(dmIDs))
|
|
args := make([]interface{}, 0, len(dmIDs)+1)
|
|
for i, id := range dmIDs {
|
|
placeholders[i] = fmt.Sprintf("$%d", i+1)
|
|
args = append(args, id)
|
|
}
|
|
args = append(args, viewerID)
|
|
viewerPlaceholder := fmt.Sprintf("$%d", len(args))
|
|
|
|
query := database.Q(fmt.Sprintf(`
|
|
SELECT cp.channel_id,
|
|
COALESCE(NULLIF(u.display_name, ''), u.username, 'Unknown')
|
|
FROM channel_participants cp
|
|
JOIN users u ON u.id = cp.participant_id
|
|
WHERE cp.channel_id IN (%s)
|
|
AND cp.participant_type = 'user'
|
|
AND cp.participant_id != %s
|
|
LIMIT %d
|
|
`, strings.Join(placeholders, ","), viewerPlaceholder, len(dmIDs)))
|
|
|
|
rows, err := database.DB.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return // non-fatal: keep original titles
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var chID, peerName string
|
|
if rows.Scan(&chID, &peerName) == nil {
|
|
if idx, ok := dmIdx[chID]; ok {
|
|
channels[idx].Title = "DM " + peerName
|
|
}
|
|
}
|
|
}
|
|
}
|