C# développe le portail WeChat et utilise le compte d'entreprise WeChat pour recevoir, traiter et décrypter les messages et les événements

1. Définition du mode de rappel du compte d'entreprise

Semblable au compte public, si le compte d'entreprise WeChat nécessite un développement secondaire, les paramètres de rappel correspondants doivent être définis en arrière-plan, comme indiqué dans le interface suivante.

Après les avoir définis et passé le contrôle, nous pouvons envoyer et recevoir des messages sur notre propre serveur d'applications WeChat.

Lors de l'entrée du message de rappel, nous devons traiter séparément les données POST et les données GET ordinaires. Les données GET sont le propre traitement de vérification de WeChat, et les données POST sont le fonctionnement interactif des messages WeChat.

    /// <summary>
    /// 企业号回调信息接口。统一接收并处理信息的入口。    /// </summary>
    public class corpapi : IHttpHandler
    {        /// <summary>
        /// 处理企业号的信息        /// </summary>
        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {

Ci-dessus, nous avons défini un gestionnaire d'application général pour traiter les messages.

Ensuite, nous séparons les différents types de messages (méthodes POST, GET) et les traitons en conséquence.

                    if (HttpContext.Current.Request.HttpMethod.ToUpper() == "POST")
                    {                        using (Stream stream = HttpContext.Current.Request.InputStream)
                        {
                            Byte[] postBytes = new Byte[stream.Length];
                            stream.Read(postBytes, 0, (Int32)stream.Length);
                            postString = Encoding.UTF8.GetString(postBytes);
                        }                        if (!string.IsNullOrEmpty(postString))
                        {
                            Execute(postString, accountInfo);
                        }
                    }                    else
                    {
                        Auth(accountInfo);
                    }

2. Vérification des messages de rappel WeChat

Voici les instructions de WeChat pour le mode de rappel et l'URL de vérification.

Vérifier la validité de l'URL

Lorsque vous soumettez les informations ci-dessus, le compte d'entreprise enverra une requête GET à l'URL renseignée. La requête GET comporte quatre paramètres, Les entreprises doivent effectuer un traitement de décodage d'URL lors de l'obtention de , sinon la vérification échouera.

参数	描述	是否必带
msg_signature	微信加密签名，msg_signature结合了企业填写的token、请求中的timestamp、nonce参数、加密的消息体	是
timestamp	时间戳	是
nonce	随机数	是
echostr	加密的随机字符串，以msg_encrypt格式提供。需要解密并返回echostr明文，解密后有random、msg_len、msg、$CorpID四个字段，其中msg即为echostr明文	首次校验时必带

L'entreprise vérifie la demande via le paramètre msg_signature. S'il est confirmé que la demande GET provient du compte d'entreprise, alors L'application d'entreprise déchiffre le paramètre echostr et renvoie le texte brut echostr comme c'est le cas (sans guillemets), alors la vérification d'accès prend effet et le mode de rappel peut être activé.

Lorsque des rappels ultérieurs seront effectués vers l'entreprise, les paramètres ci-dessus (sauf echostr) seront inclus dans l'URL de la demande et la méthode de vérification est la même que la première URL de vérification.

Selon les instructions ci-dessus, nous devons obtenir ces paramètres, puis appeler la fonction de traitement des messages fournie par WeChat pour effectuer le traitement de cryptage et de décryptage.

Dans l'opération Auth(accountInfo); de vérification de l'URL, nous pouvons voir que le contenu principal est le suivant, qui consiste à obtenir les informations de paramètre transmises, puis à les transmettre à la classe de base pour traiter le contenu de la signature du message.

                        #region 具体处理逻辑                        string echoString = HttpContext.Current.Request.QueryString["echoStr"];                        string signature = HttpContext.Current.Request.QueryString["msg_signature"];//企业号的 msg_signature
                        string timestamp = HttpContext.Current.Request.QueryString["timestamp"];                        string nonce = HttpContext.Current.Request.QueryString["nonce"];                        string decryptEchoString = "";                        if (new CorpBasicApi().CheckSignature(token, signature, timestamp, nonce, corpId, encodingAESKey, echoString, ref decryptEchoString))
                        {                            if (!string.IsNullOrEmpty(decryptEchoString))
                            {
                                HttpContext.Current.Response.Write(decryptEchoString);
                                HttpContext.Current.Response.End();
                            }
                        } 
                        #endregion

Le département du code de vérification est indiqué ci-dessous.

        /// <summary>
        /// 验证企业号签名        /// </summary>
        /// <param name="token">企业号配置的Token</param>
        /// <param name="signature">签名内容</param>
        /// <param name="timestamp">时间戳</param>
        /// <param name="nonce">nonce参数</param>
        /// <param name="corpId">企业号ID标识</param>
        /// <param name="encodingAESKey">加密键</param>
        /// <param name="echostr">内容字符串</param>
        /// <param name="retEchostr">返回的字符串</param>
        /// <returns></returns>
        public bool CheckSignature(string token, string signature, string timestamp, string nonce, string corpId, string encodingAESKey, string echostr, ref string retEchostr)
        {
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(token, encodingAESKey, corpId);            int result = wxcpt.VerifyURL(signature, timestamp, nonce, echostr, ref retEchostr);            if (result != 0)
            {
                LogTextHelper.Error("ERR: VerifyURL fail, ret: " + result);                return false;
            }            return true;
        }

3. Traitement des messages du compte d'entreprise

Ce qui précède présente le processus de vérification de l'URL du compte d'entreprise WeChat, et il existe autre Un processus de traitement de message est le processus par lequel le serveur WeChat envoie le message à notre propre serveur d'applications pour traitement. Notre serveur d'applications doit effectuer un traitement de réponse régulier en temps opportun après avoir reçu le message.

est la logique du code ci-dessous.

                    if (HttpContext.Current.Request.HttpMethod.ToUpper() == "POST")
                    {                        using (Stream stream = HttpContext.Current.Request.InputStream)
                        {
                            Byte[] postBytes = new Byte[stream.Length];
                            stream.Read(postBytes, 0, (Int32)stream.Length);
                            postString = Encoding.UTF8.GetString(postBytes);
                        }                        if (!string.IsNullOrEmpty(postString))
                        {
                            Execute(postString, accountInfo);
                        }
                    }

De même, lorsque nous répondons à un message envoyé au serveur WeChat, nous devons également obtenir les paramètres correspondants, puis construire la réponse au message.

            string echoString = HttpContext.Current.Request.QueryString["echoStr"];            string signature = HttpContext.Current.Request.QueryString["msg_signature"];//企业号的 msg_signature
            string timestamp = HttpContext.Current.Request.QueryString["timestamp"];            string nonce = HttpContext.Current.Request.QueryString["nonce"];

Et d'autres informations sur les paramètres proviennent des paramètres de configuration de notre compte d'entreprise.

            //获取配置参数并对加解密函数初始化
            string CorpToken = accountInfo.Token;            string AESKey = accountInfo.EncodingAESKey;            string CorpId = accountInfo.CorpID;

Utilisez ensuite la classe de cryptage et de décryptage des messages fournie par WeChat pour crypter et décrypter avec succès le message. Le code d'opération spécifique est le suivant.

            //根据参数信息，初始化微信对应的消息加密解密类
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(CorpToken, AESKey, CorpId);            //对收到的密文进行解析处理
            string sMsg = "";  // 解析之后的明文
            int flag = wxcpt.DecryptMsg(signature, timestamp, nonce, postStr, ref sMsg);            if (flag == 0)
            {                //LogTextHelper.Info("记录解密后的数据:");                //LogTextHelper.Info(sMsg);//记录解密后的数据
                CorpApiDispatch dispatch = new CorpApiDispatch();                string responseContent = dispatch.Execute(sMsg);                //加密后并发送                //LogTextHelper.Info(responseContent);
                string encryptResponse = "";
                timestamp = DateTime.Now.DateTimeToInt().ToString();
                wxcpt.EncryptMsg(responseContent, timestamp, nonce, ref encryptResponse, ref signature);

                HttpContext.Current.Response.ContentEncoding = Encoding.UTF8;
                HttpContext.Current.Response.Write(encryptResponse);
            }            else
            {
                LogTextHelper.Info("解密消息失败！");
            }

Enfin, nous transmettons simplement le message déchiffré à la classe d'encapsulation correspondante pour un traitement unifié.

                CorpApiDispatch dispatch = new CorpApiDispatch();                string responseContent = dispatch.Execute(sMsg);

De cette façon, lorsque nous encapsulons l'API Enterprise, nous devons uniquement nous concentrer sur la logique de la façon de répondre au message, et ne tu n'as pas à t'inquiéter pour le reste.

Plus Développement C# du portail WeChat et application de réception de compte d'entreprise WeChat, traitement et décryptage des messages et événements Pour les articles connexes, veuillez faire attention au site Web PHP chinois !