Développement C# du portail et de l'application WeChat (5) - Gestion des informations des groupes d'utilisateurs

Le mois dernier, j'ai présenté le développement de portails et d'applications WeChat en C# et j'ai écrit plusieurs essais à partager. En raison de contraintes de temps, je n'ai pas continué à écrire cette série de blogs depuis un moment. mais nous avons continué à explorer la technologie dans ce domaine en profondeur afin de mieux l'appliquer, nous nous sommes concentrés sur le développement de la technologie sous-jacente. Cet article poursuit l'introduction de l'article précédent, présentant principalement le développement et l'application de la gestion de groupe. Le contenu de cet article et de l'article précédent constituent une combinaison complète de gestion des informations sur les utilisateurs et des groupes.

1. Contenu de gestion des groupes d'utilisateurs

L'introduction des groupes d'utilisateurs vise principalement à faciliter la gestion des listes de abonnés et l'opération d'envoi de messages à différents groupes. Un compte public prend en charge jusqu'à 500 personnes. groupes.

La gestion des groupes d'utilisateurs comprend les aspects suivants :

1 Créer un groupe
2 Interroger tous les groupes
3 Interroger le groupe auquel appartient l'utilisateur
4 Modifier le nom du groupe
5 groupes d'utilisateurs mobiles

La définition de WeChat de la création de groupes est la suivante.

http请求方式: POST（请使用https协议）
https://api.weixin.qq.com/cgi-bin/groups/create?access_token=ACCESS_TOKENPOST数据格式：json
POST数据例子：{"group":{"name":"test"}}

Le résultat normalement renvoyé est le suivant.

{    "group": {        "id": 107, 
        "name": "test"
    }
}

D'autres interfaces fonctionnent de la même manière, en POSTant certains paramètres dans l'URL pour obtenir les données Json renvoyées.

Les informations sur la classe d'entité de GroupJson définies dans l'essai précédent sont les suivantes.

    /// <summary>
    /// 分组信息
    /// </summary>    public class GroupJson : BaseJsonResult
    {        /// <summary>
        /// 分组id，由微信分配
        /// </summary>
        public int id { get; set; }        /// <summary>
        /// 分组名字，UTF8编码
        /// </summary>        public string name { get; set; }
    }

Sur la base des définitions des interfaces ci-dessus, j'ai défini plusieurs interfaces et les ai résumées dans l'interface API de gestion des utilisateurs .

        /// <summary>
        /// 查询所有分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <returns></returns>
        List<GroupJson> GetGroupList(string accessToken);                       
        /// <summary>
        /// 创建分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="name">分组名称</param>
        /// <returns></returns>
        GroupJson CreateGroup(string accessToken, string name);                        
        /// <summary>
        /// 查询用户所在分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="openid">用户的OpenID</param>
        /// <returns></returns>
        int GetUserGroupId(string accessToken, string openid);        
        /// <summary>
        /// 修改分组名        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="id">分组id，由微信分配</param>
        /// <param name="name">分组名字（30个字符以内）</param>
        /// <returns></returns>
        CommonResult UpdateGroupName(string accessToken, int id, string name);                       
        /// <summary>
        /// 移动用户分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="openid">用户的OpenID</param>
        /// <param name="to_groupid">分组id</param>
        /// <returns></returns>
        CommonResult MoveUserToGroup(string accessToken, string openid, int to_groupid);

2. Mise en place de l'interface de gestion des groupes d'utilisateurs

2.1 Création d'utilisateurs Groupe

Afin d'analyser comment mettre en œuvre l'opération de données POST de création de groupes d'utilisateurs, comprenons étape par étape le processus spécifique de création d'utilisateurs.

Vous devez d'abord créer des informations de classe d'entité définies dynamiquement, qui contiennent plusieurs attributs qui doivent être mentionnés, comme indiqué ci-dessous.

            string url = string.Format("http://www.php.cn/{0}", accessToken);            var data = new
            {
                group = new
                {
                    name = name
                }
            };            string postData = data.ToJson();

Parmi eux, nous convertissons l'objet en une opération de données Json appropriée et le mettons dans la méthode d'extension ToJson. Ceci est principalement pour faciliter la dynamique. entités définies. La conversion de classe du contenu Json implique principalement l'appel de l'opération de numéro de série de Json.NET.

        /// <summary>
        /// 把对象为json字符串        /// </summary>
        /// <param name="obj">待序列号对象</param>
        /// <returns></returns>
        public static string ToJson(this object obj)
        {            return JsonConvert.SerializeObject(obj, Formatting.Indented);
        }

Après avoir préparé les données Post, nous examinerons de plus près le code d'opération pour obtenir les données et les convertir dans un format approprié.

            GroupJson group = null;
            CreateGroupResult result = JsonHelper<CreateGroupResult>.ConvertJson(url, postData);            if (result != null)
            {
                group = result.group;
            }

L'opération des données POST et leur conversion en une classe d'entité au format approprié est placée dans la méthode ConvertJson. , à l'intérieur de HttpHelper se trouve une classe auxiliaire de ma bibliothèque de classes publique. Elle appelle principalement la méthode objet httpWebRequest sous-jacente pour soumettre des données et obtenir le résultat de retour.

        /// <summary>
        /// 转换Json字符串到具体的对象        /// </summary>
        /// <param name="url">返回Json数据的链接地址</param>
        /// <param name="postData">POST提交的数据</param>
        /// <returns></returns>
        public static T ConvertJson(string url, string postData)
        {
            HttpHelper helper = new HttpHelper();            string content = helper.GetHtml(url, postData, true);
            VerifyErrorCode(content);

            T result = JsonConvert.DeserializeObject<T>(content);            return result;
        }

De cette façon, la fonction opérationnelle complète pour la création de groupes d'utilisateurs est la suivante.

        /// 

        /// 创建分组        /// 
        /// 调用接口凭证
        /// 分组名称
        /// 
        public GroupJson CreateGroup(string accessToken, string name)
        {            string url = string.Format("http://www.php.cn/{0}", accessToken);            var data = new
            {
                group = new
                {
                    name = name
                }
            };            string postData = data.ToJson();

            GroupJson group = null;
            CreateGroupResult result = JsonHelper<CreateGroupResult>.ConvertJson(url, postData);            if (result != null)
            {
                group = result.group;
            }            return group;
        }

2.2 Interroger tous les groupes

Interroger tous les groupes, vous pouvez obtenir tous les groupes sur le serveur , c'est-à-dire l'ID et le nom de chaque groupe.

        /// <summary>
        /// 查询所有分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <returns></returns>
        public List<GroupJson> GetGroupList(string accessToken)
        {            string url = string.Format("http://www.php.cn/{0}", accessToken);

            List<GroupJson> list = new List<GroupJson>();
            GroupListJsonResult result = JsonHelper<GroupListJsonResult>.ConvertJson(url);            if (result != null && result.groups != null)
            {
                list.AddRange(result.groups);
            }            return list;
        }

2.3 Interroger le groupe auquel appartient l'utilisateur

Chaque utilisateur appartient à un groupe, la valeur par défaut est Non groupé Dans ce groupe, nous pouvons obtenir les informations du groupe de l'utilisateur via l'API, c'est-à-dire obtenir l'ID du groupe d'utilisateurs.

        /// <summary>
        /// 查询用户所在分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="openid">用户的OpenID</param>
        /// <returns></returns>
        public int GetUserGroupId(string accessToken, string openid)
        {            string url = string.Format("http://www.php.cn/{0}", accessToken);            var data = new
            {
                openid = openid
            };            string postData = data.ToJson();            int groupId = -1;
            GroupIdJsonResult result = JsonHelper<GroupIdJsonResult>.ConvertJson(url, postData);            if (result != null)
            {
                groupId = result.groupid;
            }            return groupId;
        }

2.4 Modifier le nom du groupe

Vous pouvez également ajuster le groupe dans lequel se trouve l'utilisateur en pratique . Le code est le suivant.

        /// <summary>
        /// 修改分组名        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="id">分组id，由微信分配</param>
        /// <param name="name">分组名字（30个字符以内）</param>
        /// <returns></returns>
        public CommonResult UpdateGroupName(string accessToken, int id, string name)
        {            string url = string.Format("http://www.php.cn/{0}", accessToken);            var data = new
            {
                group = new
                {
                    id = id,
                    name = name
                }
            };            string postData = data.ToJson();            return Helper.GetExecuteResult(url, postData);
        }

La valeur de retour CommonResult ici est une classe d'entité qui contient un indicateur booléen de succès ou d'échec, et un message d'erreur de type String (si si n'importe lequel).

Pour le corps de la fonction GetExecuteResult, il s'agit principalement d'une fonction qui soumet des données, puis obtient les résultats et les traite en fonction des résultats.

        /// <summary>
        /// 通用的操作结果        /// </summary>
        /// <param name="url">网页地址</param>
        /// <param name="postData">提交的数据内容</param>
        /// <returns></returns>
        public static CommonResult GetExecuteResult(string url, string postData = null)
        {
            CommonResult success = new CommonResult();            try
            {
                ErrorJsonResult result;                if (postData != null)
                {
                    result = JsonHelper<ErrorJsonResult>.ConvertJson(url, postData);
                }                else
                {
                    result = JsonHelper<ErrorJsonResult>.ConvertJson(url);
                }                if (result != null)
                {
                    success.Success = (result.errcode == ReturnCode.请求成功);
                    success.ErrorMessage = result.errmsg;
                }
            }            catch (WeixinException ex)
            {                success.ErrorMessage = ex.Message;
            }            return success;
        }  
    }

La signification de la partie rouge ci-dessus est que lors de la conversion en classe d'entité, si l'erreur est définie dans WeChat, alors le message d'erreur et d'autres exceptions seront enregistrées. Je ne m'en occupe pas (c'est-à-dire le jette).

2.5 Déplacer un utilisateur vers un nouveau groupe

L'opération de déplacement d'un utilisateur vers un nouveau groupe est similaire à la section ci-dessus, veuillez consulter le code pour plus de détails.

        /// <summary>
        /// 移动用户分组        /// </summary>
        /// <param name="accessToken">调用接口凭证</param>
        /// <param name="openid">用户的OpenID</param>
        /// <param name="to_groupid">分组id</param>
        /// <returns></returns>
        public CommonResult MoveUserToGroup(string accessToken, string openid, int to_groupid)
        {            string url = string.Format("http://www.php.cn/{0}", accessToken);            var data = new
            {
                openid = openid,
                to_groupid = to_groupid
            };            string postData = data.ToJson();            return Helper.GetExecuteResult(url, postData);
        }

3. Appel de l'interface de regroupement d'utilisateurs

La section ci-dessus définit et implémente le regroupement d'utilisateurs Diverses interfaces et tous les codes liés à l'utilisateur ont été affichés sans réserve. Son fonctionnement d'appel est illustré dans le code suivant (code de test).

        private void btnGetGroupList_Click(object sender, EventArgs e)
        {
            IUserApi userBLL = new UserApi();
            List<GroupJson> list = userBLL.GetGroupList(token);            foreach (GroupJson info in list)
            {                string tips = string.Format("{0}:{1}", info.name, info.id);
                Console.WriteLine(tips);
            }
        }        private void btnFindUserGroup_Click(object sender, EventArgs e)
        {
            IUserApi userBLL = new UserApi();            int groupId = userBLL.GetUserGroupId(token, openId);            string tips = string.Format("GroupId:{0}", groupId);
            Console.WriteLine(tips);
        }        private void btnCreateGroup_Click(object sender, EventArgs e)
        {
            IUserApi userBLL = new UserApi();
            GroupJson info = userBLL.CreateGroup(token, "创建测试分组");            if (info != null)
            {                string tips = string.Format("GroupId:{0} GroupName:{1}", info.id, info.name);
                Console.WriteLine(tips);                string newName = "创建测试修改";
                CommonResult result = userBLL.UpdateGroupName(token, info.id, newName);
                Console.WriteLine("修改分组名称：" + (result.Success ? "成功" : "失败:" + result.ErrorMessage));
            }
        }        private void btnUpdateGroup_Click(object sender, EventArgs e)
        {            int groupId = 111;            string newName = "创建测试修改";

            IUserApi userBLL = new UserApi();
            CommonResult result = userBLL.UpdateGroupName(token, groupId, newName);
            Console.WriteLine("修改分组名称：" + (result.Success ? "成功" : "失败:" + result.ErrorMessage));
        }        private void btnMoveToGroup_Click(object sender, EventArgs e)
        {            int togroup_id = 111;//输入分组ID

            if (togroup_id > 0)
            {
                IUserApi userBLL = new UserApi();
                CommonResult result = userBLL.MoveUserToGroup(token, openId, togroup_id);

                Console.WriteLine("移动用户分组名称：" + (result.Success ? "成功" : "失败:" + result.ErrorMessage));
            }
        }

Après avoir compris le code ci-dessus et les règles d'appel, nous pouvons gérer les informations des groupes d'utilisateurs via l'API. En intégrant le code d'interface pertinent dans l'application, nous pouvons avoir un bon contrôle sur notre liste d'utilisateurs suivante et les informations sur les groupes d'utilisateurs. Cela constituera une base solide pour notre prochaine diffusion d’informations sur les utilisateurs.

Pour plus de développement C# des portails et applications WeChat (5) --Gestion des informations des groupes d'utilisateurs, veuillez faire attention au site Web PHP chinois pour les articles connexes !