So verwenden Sie die Web-API, um ein öffentliches WeChat-Konto zu entwickeln, um die Turing-Roboterschnittstelle aufzurufen

Passive Antwortnachricht (Rückgabe von XML)

WeChat verlangt von uns die Rückgabe von XML-Daten, und das Format ist angegeben. Weitere Informationen finden Sie in der

Entwicklerdokumentation für die öffentliche WeChat-Plattform.

Wir haben die Antwortentitätsklasse bereits zuvor geschrieben, da die Anforderung im XML-Format vorliegt.
Hier verwenden wir den von Microsoft bereitgestellten System.Xml.Serialization.XmlSerializer, um unsere Daten in XML zu serialisieren.
Also haben wir das XmlRoot-Attribut für die Klasse, das XmlEnum-Attribut für das Aufzählungsfeld und die XmlArray- und XmlArrayItem-Attribute für die Artikelliste in NewsMsg markiert. Was dann deserialisiert wird, ist das von WeChat benötigte Format.

Die Serialisierungsmethode lautet wie folgt:

public string ResponseXML(object value, Type type){
    StringWriter sw = new StringWriter();
    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();

    ns.Add("", "");　　//去除命名空间
    XmlSerializer serializer = new XmlSerializer(type);

    serializer.Serialize(sw, value, ns);    return sw.ToString();
}

Hinweis: Der XML-Namespace muss hier entfernt werden, da WeChat ihn sonst nicht erkennt

Die vollständige Methode wird bereitgestellt :

public HttpResponseMessage Post(){    var requestContent = Request.Content.ReadAsStreamAsync().Result;    //从正文参数中加载微信的请求参数
    XmlDocument xmlDoc = new XmlDocument();
    xmlDoc.Load(requestContent);

    logger.DebugFormat("WX请求XML内容:{0}", xmlDoc.InnerText);    string msgTypeStr = xmlDoc.SelectSingleNode("xml/MsgType").InnerText;    string userName = xmlDoc.SelectSingleNode("xml/FromUserName").InnerText;    string efhName = xmlDoc.SelectSingleNode("xml/ToUserName").InnerText;    string responseContent;
    MsgType msgType;    
    //获取消息类型，若未定义，则返回。
    if (!Enum.TryParse(msgTypeStr, true, out msgType))
    {           
        responseContent = MsgService.Instance.ResponseXML(new TextMsg
            {
                FromUserName = efhName,
                MsgType = MsgType.Text,
                Content = "俺还小，不知道你在说啥子(⊙_⊙)?",
                CreateTime = UnixTimestamp.Now.ToNumeric(),
                ToUserName = userName
            }, typeof(TextMsg));        return new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StringContent(responseContent, Encoding.UTF8, "application/xml"),
        };
    }    if (msgType == MsgType.Event)
    {        return ProcessEvent(xmlDoc, userName, efhName);
    }    
    //图灵消息转换为微信响应消息，下一节奉上
    string content = xmlDoc.SelectSingleNode("xml/Content").InnerText;    var requestResult = TuLingService.Instance.GetMsgFromResponse(content, userName, efhName);

    responseContent = MsgService.Instance.ResponseXML(requestResult.Data, requestResult.DataType);    return new HttpResponseMessage(HttpStatusCode.OK)
    {
        Content = new StringContent(responseContent, Encoding.UTF8, "application/xml"),
    };
}private HttpResponseMessage ProcessEvent(XmlDocument xmlDoc, string userName, string efhName){    string eventValue = xmlDoc.SelectSingleNode("xml/Event").InnerText;    var responseContent = MsgService.Instance.ResponseXML(new TextMsg
    {
        FromUserName = efhName,
        MsgType = MsgType.Text,
        Content = eventValue.ToLower().Equals("subscribe") ? "lei好哇~" : "大爷，奴家会想你的",//其实取消订阅是不会发送消息的
        CreateTime = UnixTimestamp.Now.ToNumeric(),
        ToUserName = userName
    }, typeof(TextMsg));    return new HttpResponseMessage(HttpStatusCode.OK)
    {
        Content = new StringContent(responseContent, Encoding.UTF8, "application/xml"),
    };
}

Zu diesem Zeitpunkt haben wir die Antwort auf passive WeChat-Antwortnachrichten abgeschlossen.

Zuordnung von Turing-Nachrichten und WeChat-Nachrichten

Wir haben die Funktion des passiven Antwortens auf Nachrichten implementiert. Als nächstes müssen wir die Turing-Roboterschnittstelle mit unserer öffentlichen Plattform verknüpfen.

Bei der Analyse der vom Turing-Roboter zurückgegebenen Parameter haben wir festgestellt, dass alle Arten von Inhalten Code- und Textparameter haben. Und weil wir Turings Nachricht direkt mit der Antwortnachricht von WeChat korrespondieren müssen, definieren wir eine Schnittstelle und stellen eine Konvertierungsmethode

public class TuLingResult{    //消息类型(我们在序列化为XML的时候需要提供类型)
    public Type DataType { get; set; }    public object Data { get; set; }
}public interface IResponse{    TuLingResult ToTuLingResult(string fromUserName, string toUserName);
}

bereit, um eine Textdatenentität als Basisklasse der Turing-Nachricht (entsprechend WeChat) zu erstellen Textnachrichten)

public class TextResult : IResponse{    public int Code { get; set; }    public string Text { get; set; }    public virtual TuLingResult ToTuLingResult(string fromUserName, string toUserName)    {        return new TuLingResult
        {
            DataType = typeof(TextMsg),
            Data = new TextMsg
             {
                 FromUserName = fromUserName,
                 ToUserName = toUserName,
                 Content = Text,
                 CreateTime = UnixTimestamp.Now.ToNumeric(),
                 MsgType = MsgType.Text
             }
        };
    }
}

und erstellen Sie dann nacheinander Entitätsklassen für verschiedene Daten.
Zum Beispiel: Nachrichten (entsprechend WeChat-Grafiknachrichten)

public class NewsResult : TextResult{    public List<NewsInfo> List { get; set; }    public override TuLingResult ToTuLingResult(string fromUserName, string toUserName)    {        if (List.Count > 10)
        {
            List = List.Take(10).ToList();
        }        return new TuLingResult
        {
            DataType = typeof(NewsMsg),
            Data = new NewsMsg
            {
                FromUserName = fromUserName,
                ToUserName = toUserName,
                ArticleCount = List.Count,
                Articles = List.Select(m => new MsgNewsInfo
                {
                    Title = m.Article,
                    Description = m.Source,
                    Url = m.DetailUrl,
                    PicUrl = m.Icon
                }).ToList(),
                CreateTime = UnixTimestamp.Now.ToNumeric(),
                MsgType=MsgType.News
            }
        };
    }
}public class NewsInfo{    /// <summary>
    /// 标题
    /// </summary>
    public string Article { get; set; }    /// <summary>
    /// 来源
    /// </summary>
    public string Source { get; set; }    /// <summary>
    /// 详情地址
    /// </summary>
    public string DetailUrl { get; set; }    /// <summary>
    /// 图标地址
    /// </summary>
    public string Icon { get; set; }
}

Erstellen Sie auf ähnliche Weise verschiedene Datenentitätsklassen, die von Turing Robot bereitgestellt werden

Die Datenentitäten, die wir unterstützen möchten, sind alle Nach dem Wenn die Definition abgeschlossen ist, können wir mit der Anforderung der Turing-Schnittstelle beginnen und die eigentliche Nachricht erhalten. Hier verwenden wir HttpClient, um sie zu implementieren.

private const string TULING_API_URL = "http://www.tuling123.com/openapi/api";private const string TULING_API_KEY = "XXXXX";//图灵的APIKEYpublic TuLingResult GetMsgFromResponse(string keyword, string userFlag, string efhName){    string linkString = string.Format("{0}?key={1}&info={2}&userid={3}"
        , TULING_API_URL, TULING_API_KEY, keyword, userFlag);    string content = string.Empty;    using (HttpClient client = new HttpClient())
    {
        HttpResponseMessage response = client.GetAsync(linkString).Result;

        content = response.Content.ReadAsStringAsync().Result;
        logger.DebugFormat("图灵机器人响应:{0}", content);
    }    return ConvertToMsg(content, userFlag, efhName);
}

Turing gibt den Typ der Codeidentifizierungsnachricht und die Fehlermeldung zurück. Daher analysieren wir zunächst die Antwortnachricht in TextResult und erhalten den Turing-Typ.

Definieren Sie zunächst die Turing-Typaufzählung

public enum ResultType
{
    TL_FORMAT_DATA = 50000,
    TL_TEXT_DATA = 100000,
    TL_LINK_DATA = 200000,
    TL_NOVEL_DATA = 301000,
    TL_NEWS_DATA = 302000,
    TL_APP_DATA = 304000,
    TL_TRAIN_DATA = 305000,
    TL_AIRPORT_DATA = 306000,
    TL_TUAN_DATA = 307000,
    TL_TUWEN_DATA = 308000,
    TL_HOTEL_DATA = 309000,
    TL_LOTTERY_DATA = 310000,
    TL_PRICE_DATA = 311000,
    TL_RESTAURANT_DATA = 312000,

    TL_ERROR_LENGTH = 40001,
    TL_ERROR_EMPTY = 40002,
    TL_ERROR_INVALID = 40003,
    TL_ERROR_OUTLIMIT = 40004,
    TL_ERROR_NOTSUPPORT = 40005,
    TL_ERROR_SERVERUPDATE = 40006,
    TL_ERROR_SERVERERROR = 40007
}

entsprechend dem Turing-Rückgabecode

100000  文本类数据
200000  网址类数据
301000  小说
302000  新闻
304000  应用、软件、下载
305000  列车
306000  航班
307000  团购
308000  优惠
309000  酒店
310000  彩票
311000  价格
312000  餐厅
40001   key的长度错误（32位）
40002   请求内容为空
40003   key错误或帐号未激活
40004   当天请求次数已用完
40005   暂不支持该功能
40006   服务器升级中
40007   服务器数据格式异常
50000   机器人设定的“学用户说话”或者“默认回答”

und rufen Sie dann den Nachrichtentyp ab

private ResultType GetResultType(string response)
{
    var result = JsonConvert.DeserializeObject<TextResult>(response);

    return (ResultType)result.Code;
}

Danach können wir das entsprechende TuLingResult nach verschiedenen Typen zurückgeben.

public TuLingResult ConvertToMsg(string response, string userFlag, string efhName)
{
    IResponse result = null;

    var resultType = GetResultType(response);    switch (resultType)
    {        case ResultType.TL_TEXT_DATA:
            result = JsonConvert.DeserializeObject<TextResult>(response);            break;        case ResultType.TL_LINK_DATA:
            result = JsonConvert.DeserializeObject<LinkResult>(response);            break;        case ResultType.TL_NEWS_DATA:
            result = JsonConvert.DeserializeObject<NewsResult>(response);            break;        case ResultType.TL_TUWEN_DATA:
            result = JsonConvert.DeserializeObject<TuWenResult>(response);            break;        case ResultType.TL_TRAIN_DATA:
            result = JsonConvert.DeserializeObject<TrainResult>(response);            break;        case ResultType.TL_AIRPORT_DATA:
            result = JsonConvert.DeserializeObject<AirportResult>(response);            break;        case ResultType.TL_APP_DATA:
            result = JsonConvert.DeserializeObject<AppResult>(response);            break;        case ResultType.TL_HOTEL_DATA:
            result = JsonConvert.DeserializeObject<HotelResult>(response);            break;        case ResultType.TL_PRICE_DATA:
            result = JsonConvert.DeserializeObject<PriceResult>(response);            break;        case ResultType.TL_ERROR_LENGTH:
        case ResultType.TL_ERROR_INVALID:
        case ResultType.TL_ERROR_EMPTY:
        case ResultType.TL_ERROR_OUTLIMIT:
            result = new TextResult { Text = "您的输入有误" };            break;        case ResultType.TL_ERROR_SERVERERROR:
        case ResultType.TL_ERROR_SERVERUPDATE:
            result = new TextResult { Text = "服务器忙，暂时无法为您提供服务" };            break;        case ResultType.TL_ERROR_NOTSUPPORT:
            result = new TextResult { Text = "俺还小，您说的这个还得慢慢学习，以后再来试吧" };            break;
        default:
            result = new TextResult { Text = "俺还小，不知道你在说啥子(⊙_⊙)?" };            break;
    }    return result.ToTuLingResult(efhName, userFlag);
}

Dann können wir die Daten im TuLingResult, das wir erhalten haben, in das von WeChat benötigte XML serialisieren

var requestResult = TuLingService.Instance.GetMsgFromResponse(content, userName, efhName);

responseContent = MsgService.Instance.ResponseXML(requestResult.Data, requestResult.DataType);return new HttpResponseMessage(HttpStatusCode.OK)
{
    Content = new StringContent(responseContent, Encoding.UTF8, "application/xml"),
};

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Web-API, um ein öffentliches WeChat-Konto zu entwickeln, um die Turing-Roboterschnittstelle aufzurufen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!