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

Cet article présente principalement en détail le cinquième article du développement C# du portail et de l'application WeChat, la gestion des informations des groupes d'utilisateurs, qui a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

ci-dessus au cours du mois dernier, J'ai présenté le développement de portails et d'applications WeChat en C# et écrit plusieurs essais à partager. En raison de contraintes de temps, je n'ai pas continué à écrire cette série de blogs depuis un certain temps. Ce n'est pas que j'ai arrêté de rechercher cet aspect. Au lieu de cela, nous continuerons à explorer cette technologie en profondeur et à nous concentrer sur le développement technologique sous-jacent pour une meilleure application. 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 followers et la commodité d'envoyer des messages à différents groupes Pour le fonctionnement, un compte public prend en charge la création de jusqu'à 500 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.

Méthode de requête http : POST (veuillez utiliser le protocole https)
https://api.weixin.qq.com/cgi-bin/groups/create?access_token=ACCESS_TOKEN
Format de données POST : json
Exemple de données POST : {"group":{"name":"test"}}

Les résultats normalement renvoyés sont les suivants.

{
  "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éer un groupe d'utilisateurs

Dans l'ordre analyser Comment implémenter l'opération de données POST de création de groupes d'utilisateurs ? Apprenons é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("https://api.weixin.qq.com/cgi-bin/groups/create?access_token={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 conversion des données définies dynamiquement. classes d'entités en Json Le contenu consiste principalement à appeler 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. La définition de cette méthode est la suivante, et la. HttpHelper inside est La classe auxiliaire de ma bibliothèque de classes publiques qui 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.

    /// <summary>
    /// 创建分组
    /// </summary>
    /// <param name="accessToken">调用接口凭证</param>
    /// <param name="name">分组名称</param>
    /// <returns></returns>
    public GroupJson CreateGroup(string accessToken, string name)
    {
      string url = string.Format("https://api.weixin.qq.com/cgi-bin/groups/create?access_token={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 l'ID de chaque nom de groupe.

    /// <summary>
    /// 查询所有分组
    /// </summary>
    /// <param name="accessToken">调用接口凭证</param>
    /// <returns></returns>
    public List<GroupJson> GetGroupList(string accessToken)
    {
      string url = string.Format("https://api.weixin.qq.com/cgi-bin/groups/get?access_token={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 Par défaut, il est dans le groupe non groupé. peut l'obtenir via l'API. Les informations sur le groupe d'utilisateurs servent à 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("https://api.weixin.qq.com/cgi-bin/groups/getid?access_token={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 d'opération 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("https://api.weixin.qq.com/cgi-bin/groups/update?access_token={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 (le cas échéant).

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 sera enregistré, et je ne traiterai pas d'autres exceptions (c'est-à-dire rejetées).

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("https://api.weixin.qq.com/cgi-bin/groups/members/update?access_token={0}", accessToken);
      var data = new
      {
        openid = openid,
        to_groupid = to_groupid
      };
      string postData = data.ToJson();

      return Helper.GetExecuteResult(url, postData);
    }

3. Appel des interfaces de regroupement d'utilisateurs

La section ci-dessus définit et implémente diverses interfaces pour le regroupement d'utilisateurs, toutes les codes liés à l'utilisateur ont été affichés sans réserve, et son opération d'appel est indiquée 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));
      }
    }

了解了上面的代码和调用规则，我们就能通过API进行用户分组信息的管理了。通过在应用程序中集成相关的接口代码，我们就能够很好的控制我们的关注用户列表和用户分组信息。从而为我们下一步用户的信息推送打好基础。

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!