Développement C# du portail WeChat et application de l'encapsulation et utilisation des enveloppes rouges WeChat cash

Après le dernier essai, après avoir amélioré et reconstruit l'ensemble du cadre WeChat, le paiement WeChat, le paiement d'entreprise, les enveloppes rouges en espèces, les bons et divers coupons de carte ont été emballés, et le paiement WeChat a été inclus et la partie enveloppe rouge shake est courante parties des comptes officiels et des comptes d'entreprise. Ces interfaces liées au paiement peuvent être appelées dans les comptes officiels et les comptes d'entreprise. Après une série d'optimisation et de tri, ces contenus seront ajoutés un par un, en espérant que tout le monde aime et soutienne.

1. Le concept et l'utilisation des enveloppes rouges en espèces

1) Scénarios d'utilisation

Les enveloppes rouges en espèces WeChat Pay sont développées pour les commerçants WeChat Pay. Les capacités spécifiques sont les suivantes :

◆ Lorsque les commerçants appellent l'interface, ils émettent des enveloppes rouges en spécifiant l'objet d'envoi et le montant de l'envoi. Cette méthode permet aux commerçants de l'appliquer de manière flexible à une variété de scénarios d'activité riches <.>

2) Règles d'envoi des enveloppes rouges WeChat

Règles de fréquence d'envoi

◆ Le même numéro de commerçant, le nombre maximum d'enveloppes rouges envoyées par minute Le même utilisateur envoie une enveloppe rouge

◆ Le le montant d'une seule enveloppe rouge est compris entre [1,00 yuans, 200,00 yuans] ;

◆ La même enveloppe rouge ne peut être envoyée qu'à un seul utilisateur (si les règles ci-dessus ne répondent pas à vos besoins, veuillez envoyer un e-mail ; à wxhongbao@tencent.com pour les instructions de mise à niveau)

◆ Si l'enveloppe rouge n'est pas réclamée 72 heures après son émission, elle sera traitée. Remboursement

◆ Appel d'API en arrière-plan : communiquer avec le développement en détail lors de l'entrée dans le processus de débogage commun

◆ Avertir le serveur : informer le serveur ; de l'openID de l'utilisateur qui a reçu l'enveloppe rouge WeChat, et informer le serveur du montant reçu par l'utilisateur

◆ Déduire de l'argent du compte professionnel : Une fois que le serveur aura obtenu l'information, il déduira l'argent ; de l'argent du compte professionnel correspondant Obtenez le montant correspondant ;

◆ Échec de l'appel : l'appel échoue en raison du non-respect des règles d'envoi, d'un solde insuffisant du compte professionnel, etc., et d'un retour d'informations à l'appelant ;

◆ Envoi réussi : enveloppe rouge WeChat au public Le compte envoie l'enveloppe rouge correspondante à l'utilisateur correspondant

2. Enveloppe rouge Cash

Description de l'interface et Le package C# est utilisé par les entreprises pour envoyer des enveloppes rouges aux utilisateurs individuels de WeChat. enveloppes de montants spécifiés à l’openid des utilisateurs WeChat désignés.

Paramètres de la requête

Exemple de données :

<xml><xml> 
  <sign><![CDATA[E1EE61A91C8E90F299DE6AE075D60A2D]]></sign>  
  <mch_billno><![CDATA[0010010404201411170000046545]]></mch_billno>  
  <mch_id><![CDATA[888]]></mch_id>  
  <wxappid><![CDATA[wxcbda96de0b165486]]></wxappid>  
  <send_name><![CDATA[send_name]]></send_name>  
  <re_openid><![CDATA[onqOjjmM1tad-3ROpncN-yUfa6uI]]></re_openid>  
  <total_amount><![CDATA[200]]></total_amount>  
  <total_num><![CDATA[1]]></total_num>  
  <wishing><![CDATA[恭喜发财]]></wishing>  
  <client_ip><![CDATA[127.0.0.1]]></client_ip>  
  <act_name><![CDATA[新年红包]]></act_name>  
  <remark><![CDATA[新年红包]]></remark>  
  <nonce_str><![CDATA[50780e0cca98c8c8e814883e5caa672e]]></nonce_str> 
  </xml>

Ce qui précède est une description de l'interface Et paramètres d'entrée , Dans des circonstances normales, nous devons décider comment implémenter l'encapsulation du code C# en fonction de ceux-ci. Tout d'abord, nous définissons les interfaces et les classes dont nous avons besoin, comme indiqué ci-dessous.

En analysant la description de l'interface ci-dessus, nous pouvons constater que certaines des interfaces sont des paramètres conventionnels fixes, c'est-à-dire les informations d'identité des comptes publics généraux ou des comptes d'entreprise, et certains sont des paramètres commerciaux, nous les séparons donc séparément, ce qui favorise notre encapsulation et notre utilisation de l'interface. Nous pouvons obtenir ces paramètres réguliers via l'identité du compte officiel. Pour les informations commerciales, nous pouvons définir une classe d'entité pour effectuer des données. stocker et échanger.

correspond aux paramètres conventionnels fixes dans la figure ci-dessus, comme indiqué ci-dessous dans la description de l'interface.

Par conséquent, nous pouvons définir et obtenir ces informations à partir du compte. Nous pouvons les configurer en arrière-plan de gestion, puis les supprimer et les utiliser dans la logique du code.

Selon l'introduction ci-dessus, nous pouvons définir le code d'interface de l'enveloppe rouge comme suit.

/// <summary>
    /// 微信红包（摇一摇红包）操作API
    /// </summary>
    public interface ILotteryApi
    {              
        /// <summary>
        /// 用于企业向微信用户个人发现金红包。需要商户证书
        /// 目前支持向指定微信用户的openid发放指定金额红包。
        /// </summary>
        /// <returns></returns>
        SendRedPackResult SendRedPack(SendRedPackJson json);

Parmi eux, SendRedPackJson est le paramètre métier que nous avons modifié. Nous avons défini une classe pour transporter les informations afin de faciliter le transfert d'informations via l'interface.

/// <summary>
    /// 现金红包和裂变红包的基础信息
    /// </summary>
    public class BaseRedPackJson
    {
        /// <summary>
        /// 接受红包的用户
        /// 用户openid    
        /// </summary>
        public string re_openid { get; set; }

        /// <summary>
        /// 付款金额，单位分
        /// </summary>
        public int total_amount { get; set; }

        /// <summary>
        /// 红包发放总人数
        /// </summary>
        public int total_num { get; set; }

        /// <summary>
        /// 红包祝福语
        /// </summary>
        public string wishing { get; set; }

        /// <summary>
        /// 活动名称
        /// </summary>
        public string act_name { get; set; }

        /// <summary>
        /// 备注信息
        /// </summary>
        public string remark { get; set; }
    }

    /// <summary>
    /// 发送红包的数据信息
    /// </summary>
    public class SendRedPackJson :BaseRedPackJson
    {
        /// <summary>
        /// 调用接口的机器Ip地址
        /// </summary>
        public string client_ip { get; set; }

        public SendRedPackJson()
        {
            this.total_num = 1;//红包发放总人数
        }
    }

Selon la définition des paramètres ci-dessus, nous implémentons l'interface de l'enveloppe rouge cash Le code spécifique est le suivant. à l'intérieur est principalement de transmettre Entrez les paramètres généraux et les paramètres métier, puis appelez l'adresse de l'interface pour soumettre les données (POST), obtenez les résultats renvoyés et analysez-les.

/// <summary>
        /// 用于企业向微信用户个人发现金红包。需要商户证书
        /// 目前支持向指定微信用户的openid发放指定金额红包。
        /// </summary>
        /// <returns></returns>
        public SendRedPackResult SendRedPack(SendRedPackJson json)
        {
            CheckAccount();//检查AccountInfo的对象属性值

            //加入常规的参数
            WxPayData data = new WxPayData();
            data.SetValue("wxappid", AccountInfo.UniteAppId);//公众账号appid
            data.SetValue("mch_id", AccountInfo.MchID);//商户号
            data.SetValue("nonce_str", data.GenerateNonceStr());//随机字符串
            data.SetValue("send_name", AccountInfo.Name);//    红包发送者名称
            
            //商户订单号（每个订单号必须唯一） 组成：mch_id+yyyymmdd+10位一天内不能重复的数字。
            //接口根据商户订单号支持重入，如出现超时可再调用。
            data.SetValue("mch_billno", data.GenerateOutTradeNo(AccountInfo.MchID));

            data.SetValue("re_openid", json.re_openid);
            data.SetValue("total_amount", json.total_amount);
            data.SetValue("total_num", json.total_num);
            data.SetValue("wishing", json.wishing);
            data.SetValue("client_ip", json.client_ip);
            data.SetValue("act_name", json.act_name);
            data.SetValue("remark", json.remark);

            data.SetValue("sign", data.MakeSign(AccountInfo.PayAPIKey));//最后生成签名

            var url = "https://api.mch.weixin.qq.com/mmpaymkttransfers/sendredpack";
            return Helper.GetPayResultWithCert<SendRedPackResult>(data, url, AccountInfo.CertPath, AccountInfo.CertPassword);
        }

L'opération d'envoi d'enveloppes rouges nécessite un certificat, il faut donc ajouter le certificat correspondant, et le certificat est téléchargé depuis la plateforme marchande WeChat .

Téléchargez le certificat du projet [API Security] dans le backend du marchand pour l'utiliser dans notre environnement de développement.

Après avoir téléchargé le certificat, dans l'environnement Windows, il faut généralement double-cliquer pour l'installer et saisir le numéro de commerçant requis comme mot de passe.

Dans le code, nous pouvons utiliser la classe de certificat pour ajouter

HttpHelper helper = new HttpHelper();

            helper.ClientCertificates = new X509CertificateCollection();
            certPath = Path.Combine(System.Environment.CurrentDirectory, certPath);
            helper.ClientCertificates.Add(new X509Certificate2(certPath, certPassword));
            string response = helper.GetHtml(url, xml, true);

3. Résultats de l'utilisation des enveloppes rouges WeChat

Par exemple, le code que nous appelons dans l'exemple de test est le suivant.

//现金红包
                SendRedPackJson packJson = new SendRedPackJson()
                {
                    act_name = "恭喜发财",
                    client_ip = NetworkUtil.GetIPAddress(),
                    remark = "企业红包",
                    wishing = "企业红包",
                    total_amount = 100,
                    total_num = 1,
                    re_openid = tosendOpenId //发送给用户的OpenID
                };
                var result = hbApi.SendRedPack(packJson);
                var message = string.Format("企业发送红包:{0} {1}", result.Success ? "成功" : "失败", result.Message);
                Console.WriteLine(message);
                Console.WriteLine(result.ToJson());

Le hbApi est la structure de l'interface ci-dessus, comme indiqué dans le code suivant.

AccountInfo  accountInfo = new AccountInfo()
    {
       Name = this.SendName,
        AppID = this.AppId,
        AppSecret = this.AppSecret,
        MchID = this.MchID,
        PayAPIKey = this.PayAPIKey,
        CertPath = this.CertPath,
        CertPassword = this.CertPassword,
         PayNotifyUrl = this.PayNotifyUrl
     };
 ILotteryApi hbApi = new LotteryApi(accountInfo);

Après l'appel réussi, nous pouvons voir les résultats des informations de l'enveloppe rouge dans la conversation du compte officiel. Voici l'ensemble du processus d'envoi. et en ouvrant l'enveloppe rouge.

Pour plus de développement C# du portail et de l'application WeChat, l'encapsulation et l'utilisation des enveloppes rouges WeChat Cash, veuillez faire attention au site Web PHP chinois pour les articles connexes !