Esquema de implementação de mensagens push do robot WeChat

O grupo WeChat é um lugar público onde amigos de ideias semelhantes se reúnem, e o grupo WeChat no círculo de negociação quantitativa não é exceção. Recentemente, muitos usuários FMZ perguntam como podem enviar mensagens para o grupo WeChat. Por exemplo, sua estratégia envia um sinal de negociação, mas eles não querem automatizar a transação. Eles esperam que o sinal fornecido pelo robô possa ser enviado para o grupo WeChat como referência.

Por essa razão, eu provavelmente olhei para a interface do WeChat e descobri que uma conta oficial é necessária, o que não é particularmente conveniente. Então eu decidi tomar uma abordagem diferente e tentei as seguintes soluções. Devido à capacidade limitada de mim, apenas a função mais básica deste requisito pode ser concluída, e é apenas para referência.

Plano de execução

Eu decidi usar Golang para escrever, preciso usar uma biblioteca Golanggithub.com/go-vgo/robotgo, basicamente os requisitos da solução é alcançado por esta biblioteca.

Primeiro, executamos um programa de serviço no nosso computador, o código é o seguinte:

package main 
import (
    "fmt"
    "time"
    "github.com/go-vgo/robotgo" 
    "net/http"
    "io/ioutil"
)

func postMsg (msg string) {    
    fmt.Println("Start the mission!") 
    // process ids
    processIds := "WeChat"
    fpid, err3 := robotgo.FindIds(processIds)
    robotgo.ActivePID(fpid[0])
    time.Sleep(time.Millisecond * 2000)
    if err3 == nil {
        fmt.Println(fmt.Sprintf("find %s", processIds), "ids:", fpid)
        /* Use image recognition method to get the coordinates of the click area
        arrPicFileName := []string{"pic1.png", "pic2.png", "pic3.png"}
        for _, name := range arrPicFileName {
            picPath := fmt.Sprintf("/xxx/xxx/Desktop/xxx/%s", name)
            fmt.Println("picPath:", fmt.Sprintf("/xxx/xxx/Desktop/xxx/%s", name))
            fx, fy := robotgo.FindPic(picPath)
            fmt.Println("move to :", fx+10, fy+10)
            robotgo.MoveMouseSmooth(fx+10, fy+10)
            time.Sleep(time.Millisecond * 2000)
            robotgo.MouseClick("left", false)
            robotgo.TypeStr(msg)
            time.Sleep(time.Second)
            robotgo.KeyTap("enter")
            time.Sleep(time.Second)
        }
        */

        // /* Fixed area coordinates, the coordinates of the upper right corner of the screen are 0,0
        arrArea := []map[string]int{
            map[string]int{
                "x" : 190,
                "y" : 200,
            },
            map[string]int{
                "x" : 190,
                "y" : 200+70,
            },
            map[string]int{
                "x" : 190,
                "y" : 200+70+70,
            },
        }
        for _, area := range arrArea {
            robotgo.MoveMouseSmooth(area["x"], area["y"])
            time.Sleep(time.Millisecond * 2000)
            robotgo.MouseClick("left", false)
            robotgo.TypeStr(msg)
            time.Sleep(time.Second)
            robotgo.KeyTap("enter")
            time.Sleep(time.Second)
        }
        // */
    }
    fmt.Println("The mission is complete!") 
}



func Handle (w http.ResponseWriter, r *http.Request) {
    b, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println("req body:", string(b)) 
    postMsg(string(b))
    w.Write([]byte("finished!"))
}

func main () {
    fmt.Println("listen http://127.0.0.1:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe("127.0.0.1:9090", nil)
}

A função deste programa de serviço é esperar pela solicitação.postMsgfunção para executar uma série de cliques de movimento do mouse simulados e operações de entrada para abrir a janela do software WeChat, clicar na área predefinida, inserir as informações na solicitação e enviar para o grupo WeChat.

Clique na área na janela do WeChat para confirmar e testar dois cenários.postMsgA taxa de reconhecimento deste método não é muito alta, e às vezes não pode ser reconhecida. Portanto, a segunda solução é usada, que é mais confiável. É fixar a área de clique e planejar um conjunto de coordenadas da área de clique, ou seja: as coordenadas registradas peloarrAreaonde estão as coordenadas? Resposta: Olhe para as coordenadas de pixels da captura de tela e meça T_T.

O programa de teste da estratégia da plataforma FMZ:

function main() {
    var msg = {
        "type" : "msg",
        "robotId" : _G(),
        "msg" : "hello fmz!"
    }
    var n = 0 
    while(true) {
        if(n == 20) {
            var ret = HttpQuery("http://127.0.0.1:9090/data", JSON.stringify(msg))
            Log("Exit")
            break    
        }
        n++
        LogStatus(_D(), "n:", n)
        Sleep(1000)
    }
}

Esta estratégia simula o envio de um sinal de transação (quando n==20, assumindo que o sinal de transação é acionado neste momento, e é considerado possível negociar), ele envia uma solicitação para o serviço local emhttp://127.0.0.1:9090/data.

Teste

A operação do robô FMZ (o docker também é executado localmente):

Janela do WeChat

A mensagem é:

{"type":"msg","robotId":130350,"msg":"hello fmz!"}

Este plano é apenas para começar, e se tiverem um plano melhor, são bem-vindos para o discutir.