wechat-api/hook/contact.go

package hook

import (
	"encoding/json"
	"fmt"
	"github.com/gorilla/websocket"
	"github.com/zeromicro/go-zero/core/logx"
	"strings"
	"wechat-api/workphone"
	"wechat-api/workphone/wecom"
)

// 获取标签信息
func (h *Hook) GetContactLabelList() (result GetContactLabelListReap, err error) {
	resp, err := h.Client.R().SetSuccessResult(&result).Post("http://" + h.ServerIp + ":" + h.WxPort + "/GetContactLabelList")
	if err != nil {
		return
	}
	if !resp.IsSuccessState() {
		err = fmt.Errorf("GetContactLabelList failed with status code %d", resp.StatusCode)
		return
	}
	return
}

// 获取好友和群信息
func (h *Hook) GetFriendAndChatRoomList(typeStr string) (result GetFriendAndChatRoomListReap, err error) {
	resp, err := h.Client.R().SetBody(&GetFriendAndChatRoomListReq{
		Type: typeStr,
	}).SetSuccessResult(&result).Post("http://" + h.ServerIp + ":" + h.WxPort + "/GetFriendAndChatRoomList")
	if err != nil {
		return
	}
	if !resp.IsSuccessState() {
		err = fmt.Errorf("GetFriendAndChatRoomList failed with status code %d", resp.StatusCode)
		return
	}
	return
}

// 批量获取联系人简明信息(每次100个)
func (h *Hook) BatchGetContactBriefInfo(wxids []string) (result BatchGetContactBriefInfoReap, err error) {

	wxidList := strings.Join(wxids, ",")

	resp, err := h.Client.R().SetBody(&BatchGetContactBriefInfoReq{
		WxidList: wxidList,
	}).SetSuccessResult(&result).Post("http://" + h.ServerIp + ":" + h.WxPort + "/BatchGetContactBriefInfo")
	if err != nil {
		return
	}
	if !resp.IsSuccessState() {
		err = fmt.Errorf("BatchGetChatRoomMemberWxid failed with status code %d", resp.StatusCode)
		return
	}
	return
}

// 添加新的好友
func (h *Hook) AddNewFriend(v3_wxid string, v4 string, desc string, addType string, role string) (result AddNewFriendReap, err error) {
	resp, err := h.Client.R().SetBody(&AddNewFriendReq{
		V3Wxid:  v3_wxid,
		V4:      v4,
		Desc:    desc,
		AddType: addType,
		Role:    role,
	}).SetSuccessResult(&result).Post("http://" + h.ServerIp + ":" + h.WxPort + "/AddNewFriend")
	if err != nil {
		return
	}
	if !resp.IsSuccessState() {
		err = fmt.Errorf("AddNewFriend failed with status code %d", resp.StatusCode)
		return
	}
	return
}

func (h *Hook) RequestChatRoomInfo(ChatRoomId, wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("RequestChatRoomInfo failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("RequestChatRoomInfo failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "RequestChatRoomInfoTask",
		"Content": map[string]interface{}{
			"WeChatId":   wxWxid,
			"Flag":       1,
			"ChatRoomId": ChatRoomId,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

func (h *Hook) TriggerChatroomPush(wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("TriggerChatroomPush failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("TriggerChatroomPush failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "TriggerChatroomPushTask",
		"Content": map[string]interface{}{
			"WeChatId": wxWxid,
			"Flag":     1,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

// TriggerCustomerPushTask 刷新企微联系人
func (h *Hook) TriggerCustomerPushTask(wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("TriggerCustomerPushTask failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("TriggerCustomerPushTask failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "TriggerCustomerPushTask",
		"Content": map[string]interface{}{
			"WxId": wxWxid,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

// TriggerConversationPushTask 刷新企微群组
func (h *Hook) TriggerConversationPushTask(wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("TriggerConversationPushTask failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("TriggerConversationPushTask failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "TriggerConversationPushTask",
		"Content": map[string]interface{}{
			"WxId": wxWxid,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

func (h *Hook) TriggerUserLabelTask(wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("TriggerUserLabelTask failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("TriggerUserLabelTask failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "TriggerUserLabelTask",
		"Content": map[string]interface{}{
			"WxId": wxWxid,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

func (h *Hook) TriggerContactPushTask(wxWxid string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("TriggerContactPushTask failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("TriggerContactPushTask failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "TriggerContactPushTask",
		"Content": map[string]interface{}{
			"WxId": wxWxid,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

func (h *Hook) AddFriendInChatRoom(ChatRoomId, wxWxid, friendId, desc string) error {
	conn, err := h.connWorkPhone()
	if err != nil {
		err = fmt.Errorf("AddFriendInChatRoom failed")
		return err
	}
	defer func(conn *websocket.Conn) {
		err = conn.Close()
		if err != nil {
			err = fmt.Errorf("AddFriendInChatRoom failed")
		}
	}(conn)

	message := map[string]interface{}{
		"MsgType": "AddFriendInChatRoomTask",
		"Content": map[string]interface{}{
			"WeChatId":   wxWxid,
			"ChatroomId": ChatRoomId,
			"FriendId":   friendId,
			"Message":    desc,
		},
	}
	transportMessageJSON, err := json.Marshal(message)
	if err != nil {
		return err
	}
	// 发送 JSON 消息
	err = conn.WriteMessage(websocket.TextMessage, transportMessageJSON)
	if err != nil {
		return fmt.Errorf("failed to send message: %v", err)
	}

	return nil
}

// AddFriendsTask AddFriendTask 用于添加好友任务的消息结构
type AddFriendsTask struct {
	WeChatId string   `json:"WeChatId"`
	Phones   []string `json:"Phones"`
	Message  string   `json:"message"`
	Remark   string   `json:"Remark"`
	TaskId   int64    `json:"TaskId"`
}

// FindContactTask 用于查找联系人任务的消息结构
type FindContactTask struct {
	WeChatId string `json:"WeChatId"`
	Content  string `json:"Content"`
}

// MessagePayload 用于封装消息的负载结构
type MessagePayload[T any] struct {
	Id      workphone.EnumMsgType `json:"Id"`
	MsgType string                `json:"MsgType"`
	Content T                     `json:"Content"`
}

// SendMessage 函数用于发送消息
func SendMessage[T any](hook *Hook, msgType workphone.EnumMsgType, msgTypeStr string, content T) (map[string]interface{}, error) {
	conn, err := hook.connWorkPhone()
	if err != nil {
		logx.Errorf("WebSocket 连接失败: %v", err)
		return MessagePayload[T]{}.ToMap(), err
	}
	defer func() {
		if cerr := conn.Close(); cerr != nil {
			logx.Errorf("WebSocket 关闭失败: %v", cerr)
		}
	}()

	message := MessagePayload[T]{
		Id:      msgType,
		MsgType: msgTypeStr,
		Content: content,
	}

	data, err := json.Marshal(message)
	if err != nil {
		return message.ToMap(), fmt.Errorf("JSON 序列化失败: %w", err)
	}

	if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
		return message.ToMap(), fmt.Errorf("发送消息失败: %w", err)
	}
	return message.ToMap(), nil
}

// AddFriendTask 函数用于创建并发送一个添加好友的任务
// 参数:
//
//	ownerWxId: 发起添加好友请求的微信ID
//	phone: 目标手机号
//	msg: 添加好友时附带的消息
//	taskId: 任务ID
//
// 返回值:
//
//	成功时返回包含添加好友任务信息的消息负载和nil错误
//	失败时返回空的消息负载和相应的错误
func (h *Hook) AddFriendTask(ownerWxId, phone, msg string, taskId int64) (map[string]interface{}, error) {
	if ownerWxId == "" || phone == "" || msg == "" {
		return MessagePayload[AddFriendsTask]{}.ToMap(), fmt.Errorf("invalid input parameters")
	}
	content := AddFriendsTask{
		WeChatId: ownerWxId,
		Phones:   []string{phone},
		Message:  msg,
		Remark:   "",
		TaskId:   taskId,
	}
	return SendMessage(h, workphone.EnumMsgType_AddFriendsTask, "AddFriendsTask", content)
}

// FindContactByContent 函数用于创建并发送一个查找联系人的任务
// 参数:
//
//	ownerWxId: 发起查找联系人请求的微信ID
//	contentMessage: 查找联系人的查询内容
//
// 返回值:
//
//	成功时返回包含查找联系人任务信息的消息负载和nil错误
//	失败时返回空的消息负载和相应的错误
func (h *Hook) FindContactByContent(ownerWxId, contentMessage string) (map[string]interface{}, error) {
	if ownerWxId == "" || contentMessage == "" {
		return MessagePayload[FindContactTask]{}.ToMap(), fmt.Errorf("invalid input parameters")
	}
	content := FindContactTask{
		WeChatId: ownerWxId,
		Content:  contentMessage,
	}
	return SendMessage(h, workphone.EnumMsgType_FindContactTask, "FindContactTask", content)
}

func (m MessagePayload[T]) ToMap() map[string]interface{} {
	return map[string]interface{}{
		"Id":      m.Id,
		"MsgType": m.MsgType,
		"Content": m.Content,
	}
}

// AddWecomCustomerFromSearchTask 函数用于创建并发送一个添加好友的任务
// 参数:
//
//	ownerWxId: 发起添加好友请求的微信ID
//	phone: 目标手机号 //qq号//微信id
//	msg: 添加好友时附带的消息
//	taskId: 任务ID
//
// 返回值:
//
//	成功时返回包含添加好友任务信息的消息负载和nil错误
//	失败时返回空的消息负载和相应的错误
func (h *Hook) AddWecomCustomerFromSearchTask(ownerWxId, phone, msg string, taskId int64) (map[string]interface{}, error) {
	if ownerWxId == "" || phone == "" {
		return MessagePayload[AddWecomCustomerFromSearchTask]{}.ToMap(), fmt.Errorf("invalid input parameters")
	}
	content := AddWecomCustomerFromSearchTask{
		WxId:   ownerWxId,
		Key:    phone,
		Msg:    msg,
		Memo:   "",
		TaskId: taskId,
		Labels: []string{0: ""},
	}
	return SendMessage(h, workphone.EnumMsgType(wecom.EnumMsgType_AddCustomerFromSearchTask), "AddCustomerFromSearchTask", content)
}

// AddWecomCustomerFromSearchTask  用于添加好友任务的消息结构
type AddWecomCustomerFromSearchTask struct {
	WxId   string   `json:"WxId"`
	Key    string   `json:"Key"`
	Msg    string   `json:"Msg"`
	Memo   string   `json:"Memo"`
	TaskId int64    `json:"TaskId"`
	Labels []string `json:"Labels"`
}