381 lines
11 KiB
Go
381 lines
11 KiB
Go
package handler
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"kefu-cloud/server/internal/middleware"
|
|
"kefu-cloud/server/internal/model"
|
|
)
|
|
|
|
// Export 导出客户列表 CSV（沿用列表筛选与坐席可见范围）。
|
|
// GET /api/customers/export
|
|
func (h *CustomerHandler) Export(c *gin.Context) {
|
|
tenantID := middleware.GetTenantID(c)
|
|
search := c.Query("search")
|
|
status := c.Query("status")
|
|
source := c.Query("source")
|
|
|
|
query := model.DB.Where("tenant_id = ?", tenantID)
|
|
if middleware.GetRole(c) == "agent" {
|
|
assignedCustomers := model.DB.Model(&model.Session{}).
|
|
Select("customer_id").
|
|
Where("tenant_id = ? AND agent_id = ?", tenantID, middleware.GetUserID(c))
|
|
query = query.Where("id IN (?)", assignedCustomers)
|
|
}
|
|
if search != "" {
|
|
query = query.Where("name LIKE ? OR phone LIKE ? OR email LIKE ?", "%"+search+"%", "%"+search+"%", "%"+search+"%")
|
|
}
|
|
if status != "" {
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
if source != "" {
|
|
query = query.Where("source = ?", source)
|
|
}
|
|
|
|
var customers []model.Customer
|
|
if err := query.Order("updated_at desc").Limit(exportMaxRows).Find(&customers).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "导出客户失败"})
|
|
return
|
|
}
|
|
|
|
header := []string{"ID", "姓名", "手机", "邮箱", "来源", "状态", "标签", "对话次数", "最近联系", "创建时间"}
|
|
rows := make([][]string, 0, len(customers))
|
|
for _, cu := range customers {
|
|
rows = append(rows, []string{
|
|
strconv.FormatUint(uint64(cu.ID), 10),
|
|
cu.Name,
|
|
cu.Phone,
|
|
cu.Email,
|
|
cu.Source,
|
|
cu.Status,
|
|
cu.Tags,
|
|
strconv.Itoa(cu.ConversationCount),
|
|
formatCSVTimePtr(cu.LastContactAt),
|
|
formatCSVTime(cu.CreatedAt),
|
|
})
|
|
}
|
|
name := fmt.Sprintf("customers_%s.csv", time.Now().Format("20060102_150405"))
|
|
writeCSVResponse(c, name, header, rows)
|
|
}
|
|
|
|
// Export 导出会话列表 CSV（沿用列表筛选与权限）。
|
|
// GET /api/sessions/export
|
|
func (h *SessionHandler) Export(c *gin.Context) {
|
|
tenantID := middleware.GetTenantID(c)
|
|
status := c.Query("status")
|
|
priority := c.Query("priority")
|
|
agentID := c.Query("agent_id")
|
|
channelID := c.Query("channel_id")
|
|
search := strings.TrimSpace(c.Query("search"))
|
|
from := c.Query("from")
|
|
to := c.Query("to")
|
|
|
|
query := model.DB.Model(&model.Session{}).Where("sessions.tenant_id = ?", tenantID)
|
|
if middleware.GetRole(c) == "agent" {
|
|
query = query.Where("sessions.agent_id = ? OR sessions.status = ?", middleware.GetUserID(c), "waiting")
|
|
}
|
|
if status != "" {
|
|
query = query.Where("sessions.status = ?", status)
|
|
}
|
|
if priority != "" {
|
|
query = query.Where("sessions.priority = ?", priority)
|
|
}
|
|
if agentID != "" {
|
|
query = query.Where("sessions.agent_id = ?", agentID)
|
|
}
|
|
if channelID != "" {
|
|
query = query.Where("sessions.channel_id = ?", channelID)
|
|
}
|
|
if from != "" {
|
|
if t, err := time.ParseInLocation("2006-01-02", from, time.Local); err == nil {
|
|
query = query.Where("sessions.created_at >= ?", t)
|
|
}
|
|
}
|
|
if to != "" {
|
|
if t, err := time.ParseInLocation("2006-01-02", to, time.Local); err == nil {
|
|
query = query.Where("sessions.created_at < ?", t.Add(24*time.Hour))
|
|
}
|
|
}
|
|
if search != "" {
|
|
like := "%" + search + "%"
|
|
query = query.Joins("LEFT JOIN customers ON customers.id = sessions.customer_id").
|
|
Where("customers.name LIKE ? OR CAST(sessions.id AS TEXT) LIKE ? OR COALESCE(sessions.end_reason, '') LIKE ?", like, like, like)
|
|
}
|
|
|
|
var sessions []model.Session
|
|
if err := query.Order("sessions.created_at desc").Limit(exportMaxRows).Find(&sessions).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "导出会话失败"})
|
|
return
|
|
}
|
|
|
|
customerIDs := make([]uint, 0)
|
|
agentIDs := make([]uint, 0)
|
|
channelIDs := make([]uint, 0)
|
|
sessionIDs := make([]uint, 0, len(sessions))
|
|
for _, s := range sessions {
|
|
sessionIDs = append(sessionIDs, s.ID)
|
|
customerIDs = append(customerIDs, s.CustomerID)
|
|
channelIDs = append(channelIDs, s.ChannelID)
|
|
if s.AgentID != nil {
|
|
agentIDs = append(agentIDs, *s.AgentID)
|
|
}
|
|
}
|
|
customerMap := map[uint]model.Customer{}
|
|
if len(customerIDs) > 0 {
|
|
var customers []model.Customer
|
|
model.DB.Where("id IN ?", uniqueUint(customerIDs)).Find(&customers)
|
|
for _, cu := range customers {
|
|
customerMap[cu.ID] = cu
|
|
}
|
|
}
|
|
agentMap := map[uint]model.User{}
|
|
if len(agentIDs) > 0 {
|
|
var users []model.User
|
|
model.DB.Where("id IN ?", uniqueUint(agentIDs)).Find(&users)
|
|
for _, u := range users {
|
|
agentMap[u.ID] = u
|
|
}
|
|
}
|
|
channelMap := map[uint]model.Channel{}
|
|
if len(channelIDs) > 0 {
|
|
var channels []model.Channel
|
|
model.DB.Where("id IN ?", uniqueUint(channelIDs)).Find(&channels)
|
|
for _, ch := range channels {
|
|
channelMap[ch.ID] = ch
|
|
}
|
|
}
|
|
msgCountMap := map[uint]int{}
|
|
if len(sessionIDs) > 0 {
|
|
type row struct {
|
|
SessionID uint
|
|
Cnt int
|
|
}
|
|
var rows []row
|
|
model.DB.Model(&model.Message{}).
|
|
Select("session_id, count(*) as cnt").
|
|
Where("session_id IN ?", sessionIDs).
|
|
Group("session_id").
|
|
Scan(&rows)
|
|
for _, r := range rows {
|
|
msgCountMap[r.SessionID] = r.Cnt
|
|
}
|
|
}
|
|
|
|
// 最后一条消息摘要（按会话 max(seq) 批量取）
|
|
lastMsgMap := map[uint]string{}
|
|
if len(sessionIDs) > 0 {
|
|
type lastRow struct {
|
|
SessionID uint
|
|
Content string
|
|
Type string
|
|
}
|
|
var lastRows []lastRow
|
|
_ = model.DB.Raw(`
|
|
SELECT m.session_id AS session_id, m.content AS content, m.type AS type
|
|
FROM messages m
|
|
INNER JOIN (
|
|
SELECT session_id, MAX(seq) AS max_seq
|
|
FROM messages
|
|
WHERE session_id IN ?
|
|
GROUP BY session_id
|
|
) t ON m.session_id = t.session_id AND m.seq = t.max_seq
|
|
`, sessionIDs).Scan(&lastRows).Error
|
|
for _, r := range lastRows {
|
|
if r.Type == "image" {
|
|
lastMsgMap[r.SessionID] = "[图片]"
|
|
} else {
|
|
lastMsgMap[r.SessionID] = r.Content
|
|
}
|
|
}
|
|
}
|
|
|
|
header := []string{
|
|
"会话ID", "客户", "客户手机", "坐席", "渠道", "状态", "优先级",
|
|
"消息数", "满意度", "评价内容", "结束原因", "最后消息", "创建时间", "结束时间",
|
|
}
|
|
rows := make([][]string, 0, len(sessions))
|
|
for _, s := range sessions {
|
|
custName, custPhone := "", ""
|
|
if cu, ok := customerMap[s.CustomerID]; ok {
|
|
custName, custPhone = cu.Name, cu.Phone
|
|
}
|
|
agentName := ""
|
|
if s.AgentID != nil {
|
|
if u, ok := agentMap[*s.AgentID]; ok {
|
|
agentName = u.Nickname
|
|
if agentName == "" {
|
|
agentName = u.Username
|
|
}
|
|
}
|
|
}
|
|
chName := ""
|
|
if ch, ok := channelMap[s.ChannelID]; ok {
|
|
chName = ch.Name
|
|
if chName == "" {
|
|
chName = ch.Type
|
|
}
|
|
}
|
|
rows = append(rows, []string{
|
|
strconv.FormatUint(uint64(s.ID), 10),
|
|
custName,
|
|
custPhone,
|
|
agentName,
|
|
chName,
|
|
s.Status,
|
|
s.Priority,
|
|
strconv.Itoa(msgCountMap[s.ID]),
|
|
formatIntPtr(s.SatisfactionScore),
|
|
s.SatisfactionText,
|
|
s.EndReason,
|
|
lastMsgMap[s.ID],
|
|
formatCSVTime(s.CreatedAt),
|
|
formatCSVTimePtr(s.EndedAt),
|
|
})
|
|
}
|
|
name := fmt.Sprintf("sessions_%s.csv", time.Now().Format("20060102_150405"))
|
|
writeCSVResponse(c, name, header, rows)
|
|
}
|
|
|
|
// Export 导出统计报告 CSV（KPI + 坐席绩效 + 渠道分布）。
|
|
// GET /api/statistics/export?from=&to= 或 period=
|
|
func (h *StatisticsHandler) Export(c *gin.Context) {
|
|
if !requireStatisticsAccess(c) {
|
|
return
|
|
}
|
|
r, err := parseStatsRange(c)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": err.Error()})
|
|
return
|
|
}
|
|
tenantID := middleware.GetTenantID(c)
|
|
sessions, messages, err := loadStatisticsData(tenantID, r)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "导出统计失败"})
|
|
return
|
|
}
|
|
responses := firstResponseSeconds(messages)
|
|
var responseTotal float64
|
|
for _, seconds := range responses {
|
|
responseTotal += seconds
|
|
}
|
|
var satisfactionTotal float64
|
|
satisfactionCount := 0
|
|
for _, session := range sessions {
|
|
if session.SatisfactionScore != nil {
|
|
satisfactionTotal += float64(*session.SatisfactionScore)
|
|
satisfactionCount++
|
|
}
|
|
}
|
|
avgResponse := float64(0)
|
|
if len(responses) > 0 {
|
|
avgResponse = responseTotal / float64(len(responses))
|
|
}
|
|
satisfactionAvg := float64(0)
|
|
if satisfactionCount > 0 {
|
|
satisfactionAvg = satisfactionTotal / float64(satisfactionCount)
|
|
}
|
|
|
|
// 坐席绩效
|
|
var agents []model.User
|
|
model.DB.Where("tenant_id = ? AND role = ?", tenantID, "agent").Find(&agents)
|
|
type perf struct {
|
|
Name string
|
|
Conversations int
|
|
ResponseTotal float64
|
|
ResponseCount int
|
|
Satisfaction float64
|
|
RatingCount int
|
|
}
|
|
items := make(map[uint]*perf)
|
|
for _, agent := range agents {
|
|
name := agent.Nickname
|
|
if name == "" {
|
|
name = agent.Username
|
|
}
|
|
items[agent.ID] = &perf{Name: name}
|
|
}
|
|
for _, session := range sessions {
|
|
if session.AgentID == nil || items[*session.AgentID] == nil {
|
|
continue
|
|
}
|
|
item := items[*session.AgentID]
|
|
item.Conversations++
|
|
if seconds, exists := responses[session.ID]; exists {
|
|
item.ResponseTotal += seconds
|
|
item.ResponseCount++
|
|
}
|
|
if session.SatisfactionScore != nil {
|
|
item.Satisfaction += float64(*session.SatisfactionScore)
|
|
item.RatingCount++
|
|
}
|
|
}
|
|
|
|
// 渠道
|
|
var channels []model.Channel
|
|
model.DB.Where("tenant_id = ?", tenantID).Find(&channels)
|
|
channelTypes := make(map[uint]string)
|
|
for _, channel := range channels {
|
|
channelTypes[channel.ID] = channel.Type
|
|
}
|
|
labels := map[string]string{"web": "网页", "wechat": "微信", "app": "APP", "phone": "电话工单", "email": "邮件"}
|
|
chCounts := make(map[string]int)
|
|
for _, session := range sessions {
|
|
channelType := channelTypes[session.ChannelID]
|
|
if channelType == "" {
|
|
channelType = "unknown"
|
|
}
|
|
chCounts[channelType]++
|
|
}
|
|
|
|
// 扁平 CSV：分节用 section 列
|
|
header := []string{"区块", "指标/坐席/渠道", "数值1", "数值2", "数值3", "备注"}
|
|
rows := make([][]string, 0, 32+len(items)+len(chCounts))
|
|
rows = append(rows,
|
|
[]string{"概览", "总会话数", strconv.Itoa(len(sessions)), "", "", ""},
|
|
[]string{"概览", "总消息数", strconv.Itoa(len(messages)), "", "", ""},
|
|
[]string{"概览", "平均首次响应(秒)", fmt.Sprintf("%.1f", avgResponse), "", "", ""},
|
|
[]string{"概览", "平均满意度", fmt.Sprintf("%.2f", satisfactionAvg), "", "", fmt.Sprintf("样本 %d", satisfactionCount)},
|
|
[]string{"概览", "一次解决率(%)", fmt.Sprintf("%.1f", firstResolveRate(sessions)), "", "", ""},
|
|
[]string{"概览", "导出时间", time.Now().Format("2006-01-02 15:04:05"), "", "", ""},
|
|
)
|
|
rows = append(rows, []string{"坐席绩效", "坐席", "会话数", "平均响应(秒)", "满意度", ""})
|
|
for _, agent := range agents {
|
|
item := items[agent.ID]
|
|
if item == nil {
|
|
continue
|
|
}
|
|
avgR := float64(0)
|
|
if item.ResponseCount > 0 {
|
|
avgR = item.ResponseTotal / float64(item.ResponseCount)
|
|
}
|
|
sat := float64(0)
|
|
if item.RatingCount > 0 {
|
|
sat = item.Satisfaction / float64(item.RatingCount)
|
|
}
|
|
rows = append(rows, []string{
|
|
"坐席绩效",
|
|
item.Name,
|
|
strconv.Itoa(item.Conversations),
|
|
fmt.Sprintf("%.1f", avgR),
|
|
fmt.Sprintf("%.2f", sat),
|
|
"",
|
|
})
|
|
}
|
|
rows = append(rows, []string{"渠道分布", "渠道", "会话数", "", "", ""})
|
|
for typ, cnt := range chCounts {
|
|
label := labels[typ]
|
|
if label == "" {
|
|
label = typ
|
|
}
|
|
rows = append(rows, []string{"渠道分布", label, strconv.Itoa(cnt), "", "", ""})
|
|
}
|
|
|
|
name := fmt.Sprintf("statistics_%s.csv", time.Now().Format("20060102_150405"))
|
|
writeCSVResponse(c, name, header, rows)
|
|
}
|