794 lines
24 KiB
Go
794 lines
24 KiB
Go
package biz
|
||
|
||
import (
|
||
"ai_scheduler/internal/biz/do"
|
||
"ai_scheduler/internal/biz/handle/dingtalk"
|
||
"ai_scheduler/internal/biz/tools_regis"
|
||
"ai_scheduler/internal/data/constants"
|
||
"ai_scheduler/internal/data/impl"
|
||
"ai_scheduler/internal/data/model"
|
||
"ai_scheduler/internal/domain/workflow/recharge"
|
||
"ai_scheduler/internal/domain/workflow/runtime"
|
||
"ai_scheduler/internal/entitys"
|
||
"ai_scheduler/internal/pkg/l_request"
|
||
"ai_scheduler/internal/pkg/utils_oss"
|
||
"ai_scheduler/internal/tools"
|
||
"ai_scheduler/internal/tools/bbxt"
|
||
"ai_scheduler/tmpl/dataTemp"
|
||
"io"
|
||
"net/http"
|
||
"strconv"
|
||
"time"
|
||
"unicode"
|
||
|
||
"ai_scheduler/internal/config"
|
||
"context"
|
||
"database/sql"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"strings"
|
||
|
||
"gitea.cdlsxd.cn/self-tools/l-dingtalk-stream-sdk-go/chatbot"
|
||
"github.com/coze-dev/coze-go"
|
||
"github.com/gofiber/fiber/v2/log"
|
||
"xorm.io/builder"
|
||
)
|
||
|
||
// AiRouterBiz 智能路由服务
|
||
type DingTalkBotBiz struct {
|
||
do *do.Do
|
||
handle *do.Handle
|
||
botConfigImpl *impl.BotConfigImpl
|
||
replier *chatbot.ChatbotReplier
|
||
log log.Logger
|
||
dingTalkUser *dingtalk.User
|
||
botTools []model.AiBotTool
|
||
botGroupImpl *impl.BotGroupImpl
|
||
toolManager *tools.Manager
|
||
chatHis *impl.BotChatHisImpl
|
||
conf *config.Config
|
||
cardSend *dingtalk.SendCardClient
|
||
ossClient *utils_oss.Client
|
||
workflowManager *runtime.Registry
|
||
}
|
||
|
||
// NewDingTalkBotBiz
|
||
func NewDingTalkBotBiz(
|
||
do *do.Do,
|
||
handle *do.Handle,
|
||
botConfigImpl *impl.BotConfigImpl,
|
||
botGroupImpl *impl.BotGroupImpl,
|
||
dingTalkUser *dingtalk.User,
|
||
tools *tools_regis.ToolRegis,
|
||
chatHis *impl.BotChatHisImpl,
|
||
toolManager *tools.Manager,
|
||
conf *config.Config,
|
||
cardSend *dingtalk.SendCardClient,
|
||
ossClient *utils_oss.Client,
|
||
workflowManager *runtime.Registry,
|
||
) *DingTalkBotBiz {
|
||
return &DingTalkBotBiz{
|
||
do: do,
|
||
handle: handle,
|
||
botConfigImpl: botConfigImpl,
|
||
replier: chatbot.NewChatbotReplier(),
|
||
dingTalkUser: dingTalkUser,
|
||
botTools: tools.BootTools,
|
||
botGroupImpl: botGroupImpl,
|
||
toolManager: toolManager,
|
||
chatHis: chatHis,
|
||
conf: conf,
|
||
cardSend: cardSend,
|
||
ossClient: ossClient,
|
||
workflowManager: workflowManager,
|
||
}
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) GetDingTalkBotCfgList() (dingBotList []entitys.DingTalkBot, err error) {
|
||
botConfig := make([]model.AiBotConfig, 0)
|
||
|
||
cond := builder.NewCond()
|
||
cond = cond.And(builder.Eq{"status": constants.Enable})
|
||
cond = cond.And(builder.Eq{"bot_type": constants.BotTypeDingTalk})
|
||
err = d.botConfigImpl.GetRangeToMapStruct(&cond, &botConfig)
|
||
for _, v := range botConfig {
|
||
var config entitys.DingTalkBot
|
||
err = json.Unmarshal([]byte(v.BotConfig), &config)
|
||
if err != nil {
|
||
d.log.Info("初始化“%s”失败:%s", v.BotName, err.Error())
|
||
}
|
||
config.BotIndex = v.RobotCode
|
||
dingBotList = append(dingBotList, config)
|
||
}
|
||
return
|
||
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) InitRequire(ctx context.Context, data *chatbot.BotCallbackDataModel) (requireData *entitys.RequireDataDingTalkBot, err error) {
|
||
requireData = &entitys.RequireDataDingTalkBot{
|
||
Req: data,
|
||
Ch: make(chan entitys.Response, 2),
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) Do(ctx context.Context, requireData *entitys.RequireDataDingTalkBot) (err error) {
|
||
//entitys.ResLoading(requireData.Ch, "", "收到消息，正在处理中，请稍等")
|
||
//defer close(requireData.Ch)
|
||
switch constants.ConversationType(requireData.Req.ConversationType) {
|
||
case constants.ConversationTypeSingle:
|
||
err = d.handleSingleChat(ctx, requireData)
|
||
case constants.ConversationTypeGroup:
|
||
err = d.handleGroupChat(ctx, requireData)
|
||
default:
|
||
err = errors.New("未知的聊天类型：" + requireData.Req.ConversationType)
|
||
}
|
||
if err != nil {
|
||
entitys.ResText(requireData.Ch, "", err.Error())
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleSingleChat(ctx context.Context, requireData *entitys.RequireDataDingTalkBot) (err error) {
|
||
entitys.ResLog(requireData.Ch, "", "个人聊天暂未开启，请期待后续更新")
|
||
return
|
||
//requireData.UserInfo, err = d.dingTalkUser.GetUserInfoFromBot(ctx, requireData.Req.SenderStaffId, dingtalk.WithId(1))
|
||
//if err != nil {
|
||
// return
|
||
//}
|
||
//requireData.ID=requireData.UserInfo.UserID
|
||
////如果不是管理或者不是老板，则进行权限判断
|
||
//if requireData.UserInfo.IsSenior == constants.IsSeniorFalse && requireData.UserInfo.IsBoss == constants.IsBossFalse {
|
||
//
|
||
//}
|
||
//return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleGroupChat(ctx context.Context, requireData *entitys.RequireDataDingTalkBot) (err error) {
|
||
group, err := d.initGroup(ctx, requireData.Req.ConversationId, requireData.Req.ConversationTitle, requireData.Req.RobotCode)
|
||
//宏
|
||
err, isFinal := d.Macro(ctx, requireData, group)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if isFinal {
|
||
return
|
||
}
|
||
requireData.ID = group.GroupID
|
||
groupTools, err := d.getGroupTools(ctx, group)
|
||
if err != nil {
|
||
return
|
||
}
|
||
rec, err := d.recognize(ctx, requireData, groupTools)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
return d.handleMatch(ctx, rec, group)
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) Macro(ctx context.Context, requireData *entitys.RequireDataDingTalkBot, group *model.AiBotGroup) (err error, isFinish bool) {
|
||
content := processString(requireData.Req.Text.Content)
|
||
|
||
if strings.Contains(content, "[利润同比报表]商品修改：") {
|
||
// 提取冒号后的内容
|
||
if parts := strings.SplitN(content, "：", 2); len(parts) == 2 {
|
||
itemInfo := strings.TrimSpace(parts[1])
|
||
log.Infof("商品修改信息: %s", itemInfo)
|
||
group.ProductName = itemInfo
|
||
cond := builder.NewCond()
|
||
cond = cond.And(builder.Eq{"group_id": group.GroupID})
|
||
err = d.botGroupImpl.UpdateByCond(&cond, group)
|
||
if err != nil {
|
||
entitys.ResText(requireData.Ch, "", fmt.Sprintf("修改失败:%v", err))
|
||
}
|
||
entitys.ResText(requireData.Ch, "", "修改成功")
|
||
isFinish = true
|
||
return
|
||
}
|
||
}
|
||
|
||
if strings.Contains(content, "[利润同比报表]商品列表") {
|
||
// 提取冒号后的内容
|
||
if len(group.ProductName) == 0 {
|
||
entitys.ResText(requireData.Ch, "", "暂未设置")
|
||
} else {
|
||
entitys.ResText(requireData.Ch, "", group.ProductName)
|
||
isFinish = true
|
||
}
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func processString(s string) string {
|
||
// 1. 替换中文逗号为英文逗号
|
||
s = strings.ReplaceAll(s, "，", ",")
|
||
|
||
// 2. 过滤控制字符（如 \n, \t, \r 等）
|
||
var result []rune
|
||
for _, char := range s {
|
||
// 判断是否是控制字符（ASCII < 32 或 = 127）
|
||
if !unicode.IsControl(char) {
|
||
// 如果需要完全移除 \n 和 \t，可以改成：
|
||
// if !unicode.IsControl(char)
|
||
result = append(result, char)
|
||
}
|
||
}
|
||
|
||
return string(result)
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) initGroup(ctx context.Context, conversationId string, conversationTitle string, robotCode string) (group *model.AiBotGroup, err error) {
|
||
group, err = d.botGroupImpl.GetByConversationIdAndRobotCode(conversationId, robotCode)
|
||
if err != nil {
|
||
if !errors.Is(err, sql.ErrNoRows) {
|
||
|
||
return
|
||
}
|
||
}
|
||
|
||
if group.GroupID == 0 {
|
||
group = &model.AiBotGroup{
|
||
ConversationID: conversationId,
|
||
Title: conversationTitle,
|
||
RobotCode: robotCode,
|
||
ToolList: "",
|
||
}
|
||
//如果不存在则创建
|
||
_, err = d.botGroupImpl.Add(group)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) getGroupTools(ctx context.Context, group *model.AiBotGroup) (tools []model.AiBotTool, err error) {
|
||
if len(d.botTools) == 0 {
|
||
return
|
||
}
|
||
var (
|
||
groupRegisTools = make(map[int]struct{})
|
||
)
|
||
if group.ToolList != "" {
|
||
groupToolList := strings.Split(group.ToolList, ",")
|
||
for _, tool := range groupToolList {
|
||
if tool == "" {
|
||
continue
|
||
}
|
||
num, _err := strconv.Atoi(tool)
|
||
if _err != nil {
|
||
continue
|
||
}
|
||
groupRegisTools[num] = struct{}{}
|
||
}
|
||
}
|
||
|
||
for _, v := range d.botTools {
|
||
if v.PermissionType == constants.PermissionTypeNone {
|
||
tools = append(tools, v)
|
||
continue
|
||
}
|
||
if _, ex := groupRegisTools[int(v.ToolID)]; ex {
|
||
tools = append(tools, v)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
func (d *DingTalkBotBiz) recognize(ctx context.Context, requireData *entitys.RequireDataDingTalkBot, tools []model.AiBotTool) (rec *entitys.Recognize, err error) {
|
||
|
||
userContent, err := d.getUserContent(requireData.Req.Msgtype, requireData.Req.Text.Content)
|
||
if err != nil {
|
||
return
|
||
}
|
||
rec = &entitys.Recognize{
|
||
Ch: requireData.Ch,
|
||
SystemPrompt: d.defaultPrompt(),
|
||
UserContent: userContent,
|
||
}
|
||
//历史记录
|
||
rec.ChatHis, err = d.getHis(ctx, constants.ConversationType(requireData.Req.ConversationType), requireData.ID)
|
||
if err != nil {
|
||
return
|
||
}
|
||
//工具注册
|
||
if len(tools) > 0 {
|
||
rec.Tasks = make([]entitys.RegistrationTask, 0, len(tools))
|
||
for _, task := range tools {
|
||
taskConfig := entitys.TaskConfigDetail{}
|
||
if err = json.Unmarshal([]byte(task.Config), &taskConfig); err != nil {
|
||
log.Errorf("解析任务配置失败: %s, 任务ID: %s", err.Error(), task.Index)
|
||
continue // 解析失败时跳过该任务，而不是直接返回错误
|
||
}
|
||
|
||
rec.Tasks = append(rec.Tasks, entitys.RegistrationTask{
|
||
Name: task.Index,
|
||
Desc: task.Desc,
|
||
TaskConfigDetail: taskConfig, // 直接使用解析后的配置，避免重复构建
|
||
})
|
||
}
|
||
}
|
||
err = d.handle.Recognize(ctx, rec, &do.WithDingTalkBot{})
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) getHis(ctx context.Context, conversationType constants.ConversationType, Id int32) (content entitys.ChatHis, err error) {
|
||
|
||
var (
|
||
his []model.AiBotChatHi
|
||
)
|
||
cond := builder.NewCond()
|
||
cond = cond.And(builder.Eq{"his_type": conversationType})
|
||
cond = cond.And(builder.Eq{"id": Id})
|
||
_, err = d.chatHis.GetListToStruct(&cond, &dataTemp.ReqPageBo{Limit: d.conf.Sys.SessionLen}, &his, "his_id desc")
|
||
if err != nil {
|
||
return
|
||
}
|
||
messages := make([]entitys.HisMessage, 0, len(his))
|
||
for _, v := range his {
|
||
messages = append(messages, entitys.HisMessage{
|
||
Role: constants.Caller(v.Role), // 用户角色
|
||
Content: v.Content, // 用户输入内容
|
||
Timestamp: v.CreateAt.Format(time.DateTime),
|
||
})
|
||
}
|
||
return entitys.ChatHis{
|
||
SessionId: fmt.Sprintf("%s_%d", conversationType, Id),
|
||
Messages: messages,
|
||
Context: entitys.HisContext{
|
||
UserLanguage: constants.LangZhCN, // 默认中文
|
||
SystemMode: constants.SystemModeTechnicalSupport, // 默认技术支持模式
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) getUserContent(msgType string, msgContent interface{}) (content *entitys.RecognizeUserContent, err error) {
|
||
switch constants.BotMsgType(msgType) {
|
||
case constants.BotMsgTypeText:
|
||
content = &entitys.RecognizeUserContent{
|
||
Text: msgContent.(string),
|
||
}
|
||
default:
|
||
return nil, errors.New("未知的消息类型：" + msgType)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleMatch(ctx context.Context, rec *entitys.Recognize, group *model.AiBotGroup) (err error) {
|
||
|
||
if !rec.Match.IsMatch {
|
||
if len(rec.Match.Chat) != 0 {
|
||
entitys.ResText(rec.Ch, "", rec.Match.Chat)
|
||
} else {
|
||
entitys.ResText(rec.Ch, "", rec.Match.Reasoning)
|
||
}
|
||
return
|
||
}
|
||
var pointTask *model.AiBotTool
|
||
for _, task := range d.botTools {
|
||
if task.Index == rec.Match.Index {
|
||
pointTask = &task
|
||
|
||
break
|
||
}
|
||
}
|
||
|
||
if pointTask == nil || pointTask.Index == "other" {
|
||
return d.otherTask(ctx, rec)
|
||
}
|
||
switch constants.TaskType(pointTask.Type) {
|
||
case constants.TaskTypeFunc:
|
||
return d.handleTask(ctx, rec, pointTask)
|
||
case constants.TaskTypeReport:
|
||
return d.handleReport(ctx, rec, pointTask, group)
|
||
case constants.TaskTypeCozeWorkflow:
|
||
return d.handleCozeWorkflow(ctx, rec, pointTask)
|
||
default:
|
||
return d.otherTask(ctx, rec)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleCozeWorkflow(ctx context.Context, rec *entitys.Recognize, task *model.AiBotTool) (err error) {
|
||
entitys.ResLoading(rec.Ch, task.Index, "正在执行工作流(coze)\n")
|
||
|
||
customClient := &http.Client{
|
||
Timeout: time.Minute * 30,
|
||
}
|
||
|
||
authCli := coze.NewTokenAuth(d.conf.Coze.ApiSecret)
|
||
cozeCli := coze.NewCozeAPI(
|
||
authCli,
|
||
coze.WithBaseURL(d.conf.Coze.BaseURL),
|
||
coze.WithHttpClient(customClient),
|
||
)
|
||
|
||
// 从参数中获取workflowID
|
||
type requestParams struct {
|
||
Request l_request.Request `json:"request"`
|
||
}
|
||
var config requestParams
|
||
err = json.Unmarshal([]byte(task.Config), &config)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
workflowId, ok := config.Request.Json["workflow_id"].(string)
|
||
if !ok {
|
||
return fmt.Errorf("workflow_id不能为空")
|
||
}
|
||
// 提取参数
|
||
var data map[string]interface{}
|
||
err = json.Unmarshal([]byte(rec.Match.Parameters), &data)
|
||
|
||
req := &coze.RunWorkflowsReq{
|
||
WorkflowID: workflowId,
|
||
Parameters: data,
|
||
// IsAsync: true,
|
||
}
|
||
|
||
stream := config.Request.Json["stream"].(bool)
|
||
|
||
entitys.ResLog(rec.Ch, task.Index, "工作流执行中...")
|
||
|
||
if stream {
|
||
streamResp, err := cozeCli.Workflows.Runs.Stream(ctx, req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
handleCozeWorkflowEvents(ctx, streamResp, cozeCli, workflowId, rec.Ch, task.Index)
|
||
} else {
|
||
resp, err := cozeCli.Workflows.Runs.Create(ctx, req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
entitys.ResJson(rec.Ch, task.Index, resp.Data)
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// handleCozeWorkflowEvents 处理 coze 工作流事件
|
||
func handleCozeWorkflowEvents(ctx context.Context, resp coze.Stream[coze.WorkflowEvent], cozeCli coze.CozeAPI, workflowID string, ch chan entitys.Response, index string) {
|
||
defer resp.Close()
|
||
for {
|
||
event, err := resp.Recv()
|
||
if errors.Is(err, io.EOF) {
|
||
fmt.Println("Stream finished")
|
||
break
|
||
}
|
||
if err != nil {
|
||
fmt.Println("Error receiving event:", err)
|
||
break
|
||
}
|
||
|
||
switch event.Event {
|
||
case coze.WorkflowEventTypeMessage:
|
||
entitys.ResStream(ch, index, event.Message.Content)
|
||
case coze.WorkflowEventTypeError:
|
||
entitys.ResError(ch, index, fmt.Sprintf("工作流执行错误: %s", event.Error))
|
||
case coze.WorkflowEventTypeDone:
|
||
entitys.ResEnd(ch, index, "工作流执行完成")
|
||
case coze.WorkflowEventTypeInterrupt:
|
||
resumeReq := &coze.ResumeRunWorkflowsReq{
|
||
WorkflowID: workflowID,
|
||
EventID: event.Interrupt.InterruptData.EventID,
|
||
ResumeData: "your data",
|
||
InterruptType: event.Interrupt.InterruptData.Type,
|
||
}
|
||
newResp, err := cozeCli.Workflows.Runs.Resume(ctx, resumeReq)
|
||
if err != nil {
|
||
entitys.ResError(ch, index, fmt.Sprintf("工作流恢复执行错误: %s", err.Error()))
|
||
return
|
||
}
|
||
entitys.ResLog(ch, index, "工作流恢复执行中...")
|
||
handleCozeWorkflowEvents(ctx, newResp, cozeCli, workflowID, ch, index)
|
||
}
|
||
}
|
||
fmt.Printf("done, log:%s\n", resp.Response().LogID())
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleReport(ctx context.Context, rec *entitys.Recognize, task *model.AiBotTool, group *model.AiBotGroup) error {
|
||
var configData entitys.ConfigDataReport
|
||
err := json.Unmarshal([]byte(rec.Match.Parameters), &configData)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
t, err := time.Parse(time.DateTime, configData.Time)
|
||
if err != nil {
|
||
log.Infof("时间识别失败:%s", configData.Time)
|
||
entitys.ResText(rec.Ch, "", "时间识别失败了！可以给我一份比较具体的时间吗，例如“2025-12-31 12:00,抱歉抱歉😀")
|
||
return nil
|
||
}
|
||
rep, err := bbxt.NewBbxtTools()
|
||
uploader := bbxt.NewUploader(d.ossClient)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
var reports []*bbxt.ReportRes
|
||
switch rec.Match.Index {
|
||
case "report_loss_analysis":
|
||
repo, _err := rep.StatisOursProductLossSum(t)
|
||
if _err != nil {
|
||
return _err
|
||
}
|
||
reports = append(reports, repo...)
|
||
case "report_sales_analysis":
|
||
|
||
repo, _err := rep.GetProfitRankingSum(t)
|
||
if _err != nil {
|
||
return _err
|
||
}
|
||
reports = append(reports, repo)
|
||
case "report_ranking_of_distributors":
|
||
product := strings.Split(group.ProductName, ",")
|
||
repo, _err := rep.GetStatisOfficialProductSum(t, product)
|
||
if _err != nil {
|
||
return _err
|
||
}
|
||
reports = append(reports, repo)
|
||
case "report_daily":
|
||
product := strings.Split(group.ProductName, ",")
|
||
repo, _err := rep.DailyReport(t, product, nil)
|
||
if _err != nil {
|
||
return _err
|
||
}
|
||
reports = append(reports, repo...)
|
||
default:
|
||
return fmt.Errorf("未找到的报表:%s", rec.Match.Index)
|
||
}
|
||
|
||
for _, report := range reports {
|
||
err = uploader.Run(report)
|
||
if err != nil {
|
||
log.Error(err)
|
||
continue
|
||
}
|
||
|
||
entitys.ResText(rec.Ch, "", fmt.Sprintf("%s", report.Title, report.Url))
|
||
//rec.Ch <- report.Title
|
||
//reportChan <- fmt.Sprintf("", report.Url)
|
||
//err = d.SendReport(ctx, group, report)
|
||
//if err != nil {
|
||
// log.Error(err)
|
||
// continue
|
||
//}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) handleTask(ctx context.Context, rec *entitys.Recognize, task *model.AiBotTool) (err error) {
|
||
var configData entitys.ConfigDataTool
|
||
err = json.Unmarshal([]byte(task.Config), &configData)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
err = d.toolManager.ExecuteTool(ctx, configData.Tool, rec)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) otherTask(ctx context.Context, rec *entitys.Recognize) (err error) {
|
||
entitys.ResText(rec.Ch, "", rec.Match.Reasoning)
|
||
return
|
||
}
|
||
|
||
//func (d *DingTalkBotBiz) HandleRes(ctx context.Context, data *chatbot.BotCallbackDataModel, resp entitys.Response, ch chan string) error {
|
||
// switch resp.Type {
|
||
// case entitys.ResponseText:
|
||
// return d.replyText(ctx, data.SessionWebhook, resp.Content)
|
||
// case entitys.ResponseStream:
|
||
//
|
||
// return d.replySteam(ctx, data, ch)
|
||
// case entitys.ResponseImg:
|
||
// return d.replyImg(ctx, data.SessionWebhook, resp.Content)
|
||
// case entitys.ResponseFile:
|
||
// return d.replyFile(ctx, data.SessionWebhook, resp.Content)
|
||
// case entitys.ResponseMarkdown:
|
||
// return d.replyMarkdown(ctx, data.SessionWebhook, resp.Content)
|
||
// case entitys.ResponseActionCard:
|
||
// return d.replyActionCard(ctx, data.SessionWebhook, resp.Content)
|
||
// default:
|
||
// return nil
|
||
// }
|
||
//}
|
||
|
||
func (d *DingTalkBotBiz) HandleStreamRes(ctx context.Context, data *chatbot.BotCallbackDataModel, content chan string) (err error) {
|
||
err = d.cardSend.NewCard(ctx, &dingtalk.CardSend{
|
||
RobotCode: data.RobotCode,
|
||
ConversationType: constants.ConversationType(data.ConversationType),
|
||
Template: constants.CardTempDefault,
|
||
ContentChannel: content, // 指定内容通道
|
||
ConversationId: data.ConversationId,
|
||
SenderStaffId: data.SenderStaffId,
|
||
Title: data.Text.Content,
|
||
})
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) GetReportLists(ctx context.Context, group *model.AiBotGroup) (reports []*bbxt.ReportRes, err error) {
|
||
|
||
reportList, err := bbxt.NewBbxtTools()
|
||
if err != nil {
|
||
return
|
||
}
|
||
var product []string
|
||
if group.ProductName != "" {
|
||
product = strings.Split(group.ProductName, ",")
|
||
}
|
||
//[]string{"官方-爱奇艺-星钻季卡", "官方-爱奇艺-星钻半年卡", "官方--腾讯-年卡", "官方--爱奇艺-月卡"}
|
||
reports, err = reportList.DailyReport(time.Now(), product, d.ossClient)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// 追加电商充值系统统计 - 返回统一使用 []*bbxt.ReportRes
|
||
rechargeReports, err := d.rechargeDailyReport(ctx, time.Now(), product, d.ossClient)
|
||
if err != nil || len(rechargeReports) == 0 {
|
||
return
|
||
}
|
||
|
||
reports = append(reports, rechargeReports...)
|
||
|
||
return
|
||
}
|
||
|
||
// rechargeDailyReport 获取电商充值系统统计报告
|
||
func (d *DingTalkBotBiz) rechargeDailyReport(ctx context.Context, now time.Time, productNames []string, ossClient *utils_oss.Client) (reports []*bbxt.ReportRes, err error) {
|
||
defer func() {
|
||
if err := recover(); err != nil {
|
||
log.Error(err)
|
||
}
|
||
}()
|
||
|
||
workflowId := recharge.WorkflowIDStatisticsOursProduct
|
||
args := &runtime.WorkflowArgs{
|
||
Args: map[string]any{
|
||
"product_names": productNames,
|
||
"now": now,
|
||
},
|
||
}
|
||
res, err := d.workflowManager.Invoke(ctx, workflowId, args)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
log.Infof("imgUrl: %s", res["url"].(string))
|
||
|
||
reports = []*bbxt.ReportRes{
|
||
{
|
||
ReportName: "我们的商品统计(电商充值系统)",
|
||
Title: fmt.Sprintf("%s 电商充值系统我们的商品统计", now.Format("2006-01-02")),
|
||
Path: res["path"].(string),
|
||
Url: res["url"].(string),
|
||
Data: res["data"].([][]string),
|
||
Desc: res["desc"].(string),
|
||
},
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) SendReport(ctx context.Context, groupInfo *model.AiBotGroup, report *bbxt.ReportRes) (err error) {
|
||
|
||
reportChan := make(chan string, 10)
|
||
defer close(reportChan)
|
||
reportChan <- report.Title
|
||
reportChan <- fmt.Sprintf("", report.Url)
|
||
err = d.HandleStreamRes(ctx, &chatbot.BotCallbackDataModel{
|
||
RobotCode: groupInfo.RobotCode,
|
||
ConversationType: constants.ConversationTypeGroup,
|
||
ConversationId: groupInfo.ConversationID,
|
||
Text: chatbot.BotCallbackDataTextModel{
|
||
Content: report.ReportName,
|
||
},
|
||
}, reportChan)
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) GetGroupInfo(ctx context.Context, groupId int) (group model.AiBotGroup, err error) {
|
||
|
||
cond := builder.NewCond()
|
||
cond = cond.And(builder.Eq{"group_id": groupId})
|
||
cond = cond.And(builder.Eq{"status": constants.Enable})
|
||
err = d.botGroupImpl.GetOneBySearchToStrut(&cond, &group)
|
||
|
||
return
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) ReplyText(ctx context.Context, SessionWebhook string, content string, arg ...string) error {
|
||
msg := content
|
||
if len(arg) > 0 {
|
||
msg = fmt.Sprintf(content, arg)
|
||
}
|
||
return d.replier.SimpleReplyText(ctx, SessionWebhook, []byte(msg))
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) replyImg(ctx context.Context, SessionWebhook string, content string, arg ...string) error {
|
||
msg := content
|
||
if len(arg) > 0 {
|
||
msg = fmt.Sprintf(content, arg)
|
||
}
|
||
return d.replier.SimpleReplyText(ctx, SessionWebhook, []byte(msg))
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) replyFile(ctx context.Context, SessionWebhook string, content string, arg ...string) error {
|
||
msg := content
|
||
if len(arg) > 0 {
|
||
msg = fmt.Sprintf(content, arg)
|
||
}
|
||
return d.replier.SimpleReplyText(ctx, SessionWebhook, []byte(msg))
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) replyMarkdown(ctx context.Context, SessionWebhook string, content string, arg ...string) error {
|
||
msg := content
|
||
if len(arg) > 0 {
|
||
msg = fmt.Sprintf(content, arg)
|
||
}
|
||
return d.replier.SimpleReplyText(ctx, SessionWebhook, []byte(msg))
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) replyActionCard(ctx context.Context, SessionWebhook string, content string, arg ...string) error {
|
||
msg := content
|
||
if len(arg) > 0 {
|
||
msg = fmt.Sprintf(content, arg)
|
||
}
|
||
return d.replier.SimpleReplyText(ctx, SessionWebhook, []byte(msg))
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) SaveHis(ctx context.Context, requireData *entitys.RequireDataDingTalkBot, chat []string) (err error) {
|
||
if len(chat) == 0 {
|
||
return
|
||
}
|
||
his := []*model.AiBotChatHi{
|
||
{
|
||
HisType: requireData.Req.ConversationType,
|
||
ID: requireData.ID,
|
||
Role: "user",
|
||
Content: requireData.Req.Text.Content,
|
||
},
|
||
{
|
||
HisType: requireData.Req.ConversationType,
|
||
ID: requireData.ID,
|
||
Role: "system",
|
||
Content: strings.Join(chat, "\n"),
|
||
},
|
||
}
|
||
_, err = d.chatHis.Add(his)
|
||
return err
|
||
}
|
||
|
||
func (d *DingTalkBotBiz) defaultPrompt() string {
|
||
now := time.Now().Format(time.DateTime)
|
||
return `[system] 你是一个智能路由系统，核心职责是 **精准解析用户意图并路由至对应任务模块**。请严格遵循以下规则：
|
||
[rule]
|
||
1. **返回格式**：
|
||
仅输出以下 **严格格式化的 JSON 字符串**（禁用 Markdown）：
|
||
{ "index": "工具索引index", "confidence": 0.0-1.0,"reasoning": "判断理由","parameters":"jsonstring |提取参数","is_match":true||false,"chat": "追问内容"}
|
||
关键规则（按优先级排序）：
|
||
|
||
2. **工具匹配**：
|
||
|
||
- 若匹配到工具，使用工具的 parameters 作为模板做参数匹配
|
||
- 注意区分 parameters 中的 必须参数（required） 和 可选参数（optional），按下述参数提取规则处理。
|
||
- 若**完全无法匹配**，立即设置 is_match: false，并在 chat 中已第一人称的角度提醒用户需要适用何种工具（例："请问您是要查询订单还是商品呢"）。
|
||
|
||
1. **参数提取**：
|
||
|
||
- 根据 parameters 字段列出的参数名，从用户输入中提取对应值。
|
||
- **仅提取**明确提及的参数，忽略未列出的内容。
|
||
- 必须参数仅使用用户直接提及的参数，不允许从上下文推断。
|
||
- 若必须参数缺失，立即设置 is_match: false，并在 chat 中已第一人称的角度提醒用户提供缺少的参数追问（例："需要您补充XX信息"）。
|
||
|
||
4. 格式强制要求：
|
||
-所有字段值必须是**字符串**（包括 confidence）。
|
||
-parameters 必须是 **转义后的 JSON 字符串**（如 "{\"product_name\": \"京东月卡\"}"）。
|
||
当前时间：` + now + `，所有的时间识别精确到秒`
|
||
}
|