C# développe le portail WeChat et applique l'enveloppe rouge de fission WeChat

Dans l'essai précédent "Développement C# du portail et de l'application WeChat (33) - Encapsulation et utilisation des enveloppes rouges WeChat Cash", nous avons présenté l'encapsulation et l'utilisation d'enveloppes rouges ordinaires. Ce type d'enveloppe rouge ne peut être que. envoyé à une personne à la fois, et à l'utilisateur Après avoir reçu l'enveloppe rouge, nous avons terminé. Si nous permettons aux utilisateurs de recevoir l'enveloppe rouge, nous pouvons continuer à l'envoyer à plusieurs utilisateurs afin qu'ils puissent recevoir un montant fixe ou aléatoire. C'est ce qu'on appelle une enveloppe rouge de fission. Cet essai poursuit le thème ci-dessus et continue de présenter l'encapsulation du code C# et l'utilisation de l'enveloppe rouge de fission.

1. Introduction aux enveloppes rouges de fission

Les utilisateurs qui ont reçu des enveloppes rouges de fission d'entreprise peuvent continuer à aider leurs amis à recevoir des enveloppes rouges et à diffuser des enveloppes rouges d'entreprise à plus d'amis sous forme de fission, donner au marketing plus de plaisir et de plaisir ! Les enveloppes rouges de fission renforcent continuellement l'effet de marque d'entreprise et forment une communication de fission, qui est un outil marketing pour la promotion de la marque. Les entreprises n'ont qu'à spécifier le nombre et le montant total d'un groupe d'enveloppes rouges, et WeChat Pay calculera le montant de chaque enveloppe rouge, ce qui est simple et pratique.

Les enveloppes rouges de fission WeChat Pay sont développées pour les commerçants WeChat Pay. Les capacités spécifiques sont les suivantes :

Lorsque le commerçant appelle l'interface, il émet un ensemble d'enveloppes rouges de fission en spécifiant. le montant de l'envoi et en spécifiant un expéditeur.

2. Une fois que l'expéditeur désigné a reçu l'enveloppe rouge, les fonds seront directement transférés vers le changement WeChat, offrant aux utilisateurs une expérience fluide du paiement WeChat. 3. L'expéditeur désigné peut partager les enveloppes rouges restantes de la combinaison. Donnez-les à des amis, qui peuvent continuer à les recevoir, formant ainsi un effet de communication et amplifiant la valeur de la marque de l'entreprise

Le processus de traitement global et l'interface de Les enveloppes rouges à fission ne sont pas très différentes des enveloppes rouges à fission ordinaires. Après avoir compris les enveloppes rouges à fission, l'encapsulation des enveloppes rouges à fission et le processus d'utilisation devraient être un jeu d'enfant.

L'interface de l'enveloppe rouge de fission est utilisée par les entreprises pour envoyer des enveloppes rouges de fission à des utilisateurs individuels de WeChat

Actuellement, elle prend en charge l'émission d'enveloppes rouges de fission de montants spécifiés à l'openid des utilisateurs WeChat désignés. (Pour obtenir openid, veuillez vous référer à la documentation du développeur de la plateforme publique WeChat : autorisation de page Web pour obtenir des informations utilisateur de base)

La relation correspondante entre les paramètres d'interface et l'effet réel de l'application utilisateur est la suivante :

Description de la demande d'appel d'interface

Semblable à l'enveloppe rouge cash introduite plus tôt, nous pouvons également diviser les paramètres de l'enveloppe rouge de fission en deux parties, l'une est le paramètre régulier et l'autre est le paramètre commercial, comme montré ci-dessous.

2. Encapsulation du code C# de l'enveloppe rouge de fission

À partir des paramètres ci-dessus passés, nous pouvons la diviser en deux parties lorsque nous passons dans ce qui suit. paramètres

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

Une fois les paramètres entrants ci-dessus soumis à l'adresse : https://api.mch.weixin.qq.com/mmpaymkttransfers/sendgroupredpack, le XML suivant sera renvoyé après succès.

<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[发放成功.]]></return_msg> 
   <result_code><![CDATA[SUCCESS]]></result_code> 
   <err_code><![CDATA[0]]></err_code> 
   <err_code_des><![CDATA[发放成功.]]></err_code_des> 
   <mch_billno><![CDATA[0010010404201411170000046545]]></mch_billno> 
   <mch_id>10010404</mch_id> 
   <wxappid><![CDATA[wx6fa7e3bab7e15415]]></wxappid> 
   <re_openid><![CDATA[onqOjjmM1tad-3ROpncN-yUfa6uI]]></re_openid> 
   <total_amount>3</total_amount> 
   <send_time><![CDATA[20150227091010]]></send_time>
   <send_listid><![CDATA[1000000000201502270093647546]]></send_listid>
</xml>

En cas d'échec, le XML renvoyé manquera de beaucoup d'informations, comme indiqué ci-dessous.

<xml>
   <return_code><![CDATA[FAIL]]></return_code>
   <return_msg><![CDATA[系统繁忙,请稍后再试.]]></return_msg>
   <result_code><![CDATA[FAIL]]></result_code>
   <err_code><![CDATA[268458547]]></err_code>
   <err_code_des><![CDATA[系统繁忙,请稍后再试.]]></err_code_des>
   <mch_billno><![CDATA[0010010404201411170000046542]]></mch_billno>
   <mch_id>10010404</mch_id>
   <wxappid><![CDATA[wx6fa7e3bab7e15415]]></wxappid>
   <re_openid><![CDATA[onqOjjmM1tad-3ROpncN-yUfa6uI]]></re_openid>
   <total_amount>3</total_amount>
</xml>

Selon ces règles, nous avons encapsulé l'interface et le code d'implémentation de l'enveloppe rouge de fission pour une meilleure utilisation.

Par exemple, sur la base des caractéristiques similaires des classes d'entités des enveloppes rouges de trésorerie ordinaires et des enveloppes rouges de fission, nous avons conçu plusieurs classes pour stocker les informations. La relation d'objet des paramètres entrants est affichée dans le. figure ci-dessous.

De même, pour les résultats d'envoi d'enveloppe rouge retournés, puisqu'il faut considérer le retour d'informations en cas d'erreur et le retour d'informations réussi, nous avons conçu la relation entre les classes de résultats de retour comme suit Show.

Sur la base des idées de conception ci-dessus, le code de classe que nous avons conçu est le suivant.

/// <summary>
    /// 发送裂变红包的数据信息
    /// </summary>
    public class SendGroupRedPackJson : BaseRedPackJson
    {     
        /// <summary>
        /// 红包金额设置方式
        /// ALL_RAND—全部随机,商户指定总金额和红包发放总人数，由微信支付随机计算出各红包金额
        /// </summary>
        public string amt_type { get; set; }

        public SendGroupRedPackJson()
        {
            this.amt_type = "ALL_RAND";
        }
    }

Le code de la classe d'objet résultat est le suivant.

/// <summary>
    /// 发送红包的返回结果
    /// </summary>
    public class SendRedPackResult : PayResult
    {
        /// <summary>
        /// 商户订单号
        /// </summary>
        public string mch_billno { get; set; }

        /// <summary>
        /// 商户appid，接口传入的所有appid应该为公众号的appid（在mp.weixin.qq.com申请的），不能为APP的appid（在open.weixin.qq.com申请的）。
        /// </summary>
        public string wxappid { get; set; }
        /// <summary>
        /// 接受收红包的用户 
        /// 用户在wxappid下的openid
        /// </summary>
        public string re_openid { get; set; }
        /// <summary>
        /// 付款金额，单位分
        /// </summary>
        public int total_amount { get; set; }
        /// <summary>
        /// 红包发送时间
        /// </summary>
        public string send_time { get; set; }
        /// <summary>
        /// 红包订单的微信单号
        /// </summary>
        public string send_listid { get; set; }
    }

De cette façon, avec les codes de ces objets, nous suivons toujours la méthode de conception d'interface introduite dans l'essai précédent selon la description de l'interface pour implémenter le code traitement des enveloppes rouges de fission .

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

        /// <summary>
        /// 用于企业向微信用户个人发裂变红包。需要商户证书
        /// 目前支持向指定微信用户的openid发放指定金额裂变红包。
        /// </summary>
        /// <returns></returns>
        SendRedPackResult SendGroupRedPack(SendGroupRedPackJson json);

        .............

Ensuite, le code d'interface pour les implémenter est le suivant.

/// <summary>
    /// 微信红包管理类
    /// </summary>
    public class LotteryApi : ILotteryApi
    {
        #region 裂变红包说明
        //微信支付裂变红包向微信支付商户开发，具体能力如下： 
        //1、商户调用接口时，通过指定发送金额以及指定一位发送对象的方式发放一组裂变红包
        //2、指定发送对象领取到红包后，资金直接进入微信零钱，带给用户微信支付原生的流畅体验
        //3、指定发送对象能够将组合中的剩余红包分享给好友，好友可继续领取，形成传播效应，放大企业品牌价值
        #endregion

        /// <summary>
        /// 用于企业向微信用户个人发裂变红包。需要商户证书
        /// 目前支持向指定微信用户的openid发放指定金额裂变红包。
        /// </summary>
        /// <returns></returns>
        public SendRedPackResult SendGroupRedPack(SendGroupRedPackJson 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("act_name", json.act_name);
            data.SetValue("remark", json.remark);
            data.SetValue("amt_type", json.amt_type);

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

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

        ...............</sendredpackresult>

3. Appel et affichage des effets de l'interface de l'enveloppe rouge de fission

Ci-dessus, nous avons encapsulé l'interface de l'enveloppe rouge de fission si nous en avons besoin. envoyer une enveloppe rouge de fission Lors de l'envoi d'enveloppes rouges, vous pouvez appeler directement l'interface ci-dessus pour réaliser l'opération d'envoi d'enveloppes rouges.

Par exemple, le code pour appeler l'interface est le suivant.

//裂变红包
                SendGroupRedPackJson groupJson = new SendGroupRedPackJson()
                {  
                    act_name = "恭喜发财",
                    remark = "企业红包",
                    wishing = "企业红包",
                    total_amount = 600,
                    total_num = 4,
                    re_openid = tosendOpenId, //发送给用户的OpenID
                };

                var groupResult = hbApi.SendGroupRedPack(groupJson);
                message = string.Format("企业发送裂变红包:{0} {1}", groupResult.Success ? "成功" : "失败", groupResult.Message);
                Console.WriteLine(message);
                Console.WriteLine(groupResult.ToJson());

Le code d'initialisation de l'objet de hbApi est le suivant

ILotteryApi hbApi = new LotteryApi(accountInfo);

Enfin on peut voir l'enveloppe rouge de fission envoyée sur WeChat.

Puisque le montant des enveloppes rouges envoyées doit être supérieur à 1 yuan, alors si le montant que nous envoyons est plus grand, alors tout le monde le divisera. Le nombre d'enveloppes rouges varie, comme le montre l'image ci-dessous.

Ce qui précède concerne l'encapsulation de l'interface et le processus d'utilisation des enveloppes rouges en espèces et des enveloppes rouges à fission. J'espère que cela vous sera utile dans l'utilisation du développement WeChat. votre soutien.

Pour plus d'articles liés au développement C# du portail WeChat et à l'application des enveloppes rouges de fission WeChat, veuillez faire attention au site Web PHP chinois !