Comment utiliser l'API Web pour développer un compte public WeChat afin d'appeler l'interface du robot Turing

Message de réponse passive (renvoyant du XML)

WeChat nous demande de renvoyer des données XML, et le format est spécifié pour plus de détails, veuillez consulter

Documentation du développeur de la plateforme publique WeChat.

Nous avons déjà écrit la classe d'entité de réponse auparavant, car l'exigence est au format XML.
Ici, nous utilisons le System.Xml.Serialization.XmlSerializer fourni par Microsoft pour sérialiser nos données en XML.
Nous avons donc marqué l'attribut XmlRoot sur la classe, l'attribut XmlEnum sur le champ énuméré et les attributs XmlArray et XmlArrayItem sur la liste d'articles dans NewsMsg. Ce qui est ensuite désérialisé est le format requis par WeChat.

La méthode de sérialisation est la suivante :

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();
}

Remarque : L'espace de noms XML doit être supprimé ici, sinon WeChat ne le reconnaîtra pas

La méthode complète est fournie. :

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"),
    };
}

À ce stade, nous avons terminé la réponse aux messages de réponse passive WeChat.

Mappage des messages Turing et des messages WeChat

Nous avons implémenté la fonction de réponse passive aux messages. Ensuite, nous devons associer l'interface du robot Turing à notre plateforme publique.

En analysant les paramètres renvoyés par le robot Turing, nous avons constaté que tous les types de contenu ont des paramètres de code et de texte. Et parce que nous devons faire correspondre directement le message de Turing au message de réponse de WeChat, nous définissons une interface et fournissons une méthode de conversion

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

pour créer une entité de données texte comme classe de base du message de Turing (correspondant à WeChat messages texte)

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
             }
        };
    }
}

, puis créez des classes d'entités pour diverses données en séquence.
Par exemple : Actualités (correspondant aux messages graphiques WeChat)

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; }
}

Créez de la même manière diverses classes d'entités de données fournies par Turing Robot

Les entités de données que nous souhaitons prendre en charge sont toutes après le la définition est terminée, nous pouvons commencer à demander l'interface Turing et obtenir le vrai message Ici, nous utilisons HttpClient pour l'implémenter.

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 renvoie le type de message d'identification du code et le message d'erreur, nous analysons donc d'abord le message de réponse dans TextResult et obtenons le type Turing.

Définissez d'abord l'énumération du type Turing

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
}

correspondant au code retour Turing

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

puis récupérez le type de message

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

    return (ResultType)result.Code;
}

Après cela, nous pouvons renvoyer le TuLingResult correspondant selon différents types.

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);
}

Ensuite, nous pouvons sérialiser les données dans le TuLingResult que nous avons obtenu dans le XML requis par WeChat

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"),
};

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!