biBackService/service/kbService.go

package service

import (
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/go-xweb/log"
	. "biBackService/config"
	"biBackService/public"
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

// 定义消息结构体
type WechatWorkMessage struct {
	MsgType string      `json:"msgtype"`
	Text    TextContent `json:"text"`
}

type TextContent struct {
	Content string `json:"content"`
}

type WordTask struct {
	Title       string `json:"title"`
	Description string `json:"description"`
	Color_id    string `json:"color_id"`
	Project_id  int    `json:"project_id"`
	Column_id   int    `json:"column_Id"`
	Position    int    `json:"position"`
	Score       int    `json:"score"`
	Creator_id  int    `json:"creator_id"`
	Swimlane_id int    `json:"swimlane_Id"`
}

func CheckCreateUserAccount(name string) (accountId int, err error) {
	if name == "" {
		return 0, errors.New("名字不能为空")
	}
	if len([]rune(name)) == 11 {
		return 0, errors.New("请确认获取名字是否正确")
	}
	res := KbDb.FindOne("users", map[string]interface{}{"name": name}, "id", "id DESC")
	if res != nil && len(*res) > 0 {
		accountId = common.IntAll((*res)["id"])
	} else {
		fullNamePy, username := public.ConvertToPinyin(name)
		in := KbDb.Insert("users", map[string]interface{}{
			"username":     username,
			"password":     "$2y$10$pZhH7qLlW2bh1Qk.UjOkgekVPkpCjG1KfRhv3H0FXidx51a1ZntB2",
			"is_ldap_user": 0,
			"name":         name,
			"email":        fmt.Sprintf("%s@topnet.net.cn", fullNamePy),
		})
		if in < 0 {
			return 0, errors.New("创建用户信息出错")
		}
		accountId = int(in)
	}

	return accountId, nil
}

func (wt *WordTask) WordTaskSave() (err error) {
	in := KbDb.Insert("tasks", map[string]interface{}{
		"title":             wt.Title,
		"description":       wt.Description,
		"color_id":          wt.Color_id,
		"project_id":        wt.Project_id,
		"column_Id":         wt.Column_id,
		"position":          wt.Position,
		"score":             wt.Score,
		"creator_id":        wt.Creator_id,
		"swimlane_id":       wt.Swimlane_id,
		"date_creation":     time.Now().Unix(),
		"date_modification": time.Now().Unix(),
		"date_moved":        time.Now().Unix(),
		"priority":          2,
	})
	if in < 0 {
		return errors.New("创建任务失败")
	}
	return nil
}

func GetFilePath(fm, types string) (s string) {
	var tm = time.Now().Format("20060102")
	var path = SysConfig.FilePath + types + "/" + tm[:4] + "/" + tm[4:6] + "/"
	os.MkdirAll(path, 0700)
	return path + fm
}

func SendWechatWorkMessage() error {
	// 构造请求URL
	baseURL := SysConfig.WechatWorkUrl
	params := url.Values{}
	params.Add("key", SysConfig.WechatWorkKey)
	fullURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
	message := map[string]interface{}{
		"msgtype": "text",
		"text": map[string]interface{}{
			"content":               "您有一个新工单，请及时处理",
			"mentioned_mobile_list": SysConfig.WechatRemind,
		},
	}
	payload, err := json.Marshal(message)
	if err != nil {
		return fmt.Errorf("JSON序列化失败: %v", err)
	}

	// 创建HTTP请求
	req, err := http.NewRequest("POST", fullURL, bytes.NewBuffer(payload))
	if err != nil {
		return fmt.Errorf("发送企微消息创建请求失败: %v", err)
	}
	req.Header.Set("Content-Type", "application/json")

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("发送企微消息请求发送失败: %v", err)
	}
	defer resp.Body.Close()

	// 处理响应
	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		return fmt.Errorf("发送企微消息API返回错误: 状态码 %d, 响应: %s", resp.StatusCode, string(body))
	}

	// 解析响应内容（可选）
	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return fmt.Errorf("发送企微消息响应解析失败: %v", err)
	}

	if errcode, ok := result["errcode"].(float64); ok && errcode != 0 {
		return fmt.Errorf("企业微信API错误: %v", result["errmsg"])
	}
	return nil
}

func GetTitleByContent(content string) (toTitle string, err error) {
	reqUrl := SysConfig.WorkflowsUrl
	method := "POST"
	param := map[string]interface{}{
		"inputs": map[string]interface{}{
			"content": content,
		},
		"response_mode": "blocking",
		"user":          SysConfig.WorkflowsUser,
	}
	jsonData, err := json.Marshal(param)
	if err != nil {
		return
	}
	payload := strings.NewReader(string(jsonData))

	client := &http.Client{}
	req, err := http.NewRequest(method, reqUrl, payload)
	if err != nil {
		return
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", "Bearer app-w7OhSixqrVvZLa3wIEXNeoOh")
	res, err := client.Do(req)
	if err != nil {
		return
	}
	defer res.Body.Close()

	var result map[string]interface{}
	if err = json.NewDecoder(res.Body).Decode(&result); err != nil {
		return
	}
	log.Println("result", result)
	if data, ok := result["data"].(map[string]interface{}); ok {
		if outputs, oks := data["outputs"].(map[string]interface{}); oks {
			toTitle = strings.Replace(common.ObjToString(outputs["title"]), "标题：", "", -1)
		}
	}
	//toTitle = string(body)
	return
}

func GetQywxUserId() {
	userIdMap := map[string]string{}
	data := GfastDb.SelectBySql("select userid,email from jy_qywx_user where status = 1")
	if data != nil && len(*data) > 0 {
		for _, v := range *data {
			userIdMap[common.InterfaceToStr(v["email"])] = common.InterfaceToStr(v["userid"])
		}
	}

	QywxUserIdMap = userIdMap
}