Fonction de gestion des balises de compte public WeChat développée par C# WeChat

Le compte public WeChat, suivant l'idée du compte d'entreprise, ajoute la fonction de gestion des balises qui peut être définie pour les fans qui le suivent afin d'obtenir une fonction de gestion de groupe plus pratique. Les développeurs peuvent utiliser les interfaces pertinentes de gestion des balises utilisateur pour créer, interroger, modifier, supprimer et d'autres opérations sur les balises de compte public, et peuvent également baliser et annuler les balises pour les utilisateurs. Cet essai présente principalement comment utiliser C# pour encapsuler la nouvelle fonctionnalité des comptes publics et réaliser la fonction de gestion des balises.

1. Introduction à la fonction d'étiquette

1) La fonction d'étiquette remplace la fonction de regroupement et prend en charge la définition multidimensionnelle des attributs utilisateur

Les opérateurs peuvent se connecter Dans le backend de la plateforme publique, cliquez sur « Gestion des utilisateurs » dans le menu de gauche pour gérer les utilisateurs que vous avez suivis. Cliquez sur l'icône « Tag » sur le côté droit de l'un des utilisateurs pour faire apparaître une vérification. pour ajouter rapidement une balise à l'utilisateur, et la case à cocher Ajouter une balise prend en charge la création directe de nouvelles balises.

De plus, l'interface de la fonction de balise a également été mise à jour. Les développeurs peuvent appeler l'interface pour implémenter les opérations de balise et d'utilisateur. Dans le même temps, l'interface de messagerie de groupe avancée et l'interface de menu personnalisée prennent déjà en charge les opérations basées sur des balises.

2) Optimiser les cartes utilisateur, prendre en charge l'affichage des avatars des utilisateurs et des données interactives dans plusieurs scénarios, et améliorer la familiarité des opérateurs avec les utilisateurs et l'efficacité de la gestion

Ce numéro ajoute de nouvelles données interactives telles que le nombre de messages, de commentaires et d'appréciations, affiche le temps d'attention de l'utilisateur et prend en charge la visualisation de l'image de l'avatar de l'utilisateur, ce qui est utile pour raccourcir la distance entre l'opérateur et l'utilisateur. De plus, il prend en charge les scénarios de « fonction d'appréciation » et de « gestion des messages » pour gérer directement les utilisateurs afin d'améliorer l'efficacité de la gestion.

2. Encapsulation de l'interface des balises

L'interface des balises est divisée en deux parties : la gestion des balises et la gestion des utilisateurs. Un compte public peut créer jusqu'à 100 balises. La fonction d'étiquette prend actuellement en charge les comptes publics pour étiqueter jusqu'à trois étiquettes pour les utilisateurs.

La gestion des balises comprend :

1) Créer des balises 2) Obtenir des balises créées par des comptes publics 3) Modifier des balises 4) Supprimer des balises 5) Obtenir des fans sous des balises Gestion des utilisateurs de la liste

les balises comprennent :

1) Marquer les utilisateurs par lots 2) Démarquer les utilisateurs par lots 3) Obtenir la liste des balises sur les utilisateurs

Ce qui suit est une introduction pertinente à plusieurs encapsulations d'interface.

Tout d'abord, de manière conventionnelle, nous définissons les interfaces pertinentes et les relations de mise en œuvre, comme le montre la figure ci-dessous.

Selon la description de l'interface pertinente, nous pouvons implémenter la définition de l'interface d'étiquette Le code C# est le suivant.

/// <summary>
/// 微信标签管理的API接口
/// 开发者可以使用用户标签管理的相关接口，实现对公众号的标签进行创建、查询、修改、删除等操作，也可以对用户进行打标签、取消标签等操作。
/// </summary>
public interface ITagApi
{ 
/// <summary>
/// 创建标签
/// 一个公众号，最多可以创建100个标签。
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="name">标签名（30个字符以内）</param>
/// <returns></returns>
TagJson CreateTag(string accessToken, string name);
/// <summary>
/// 获取公众号已创建的标签
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <returns></returns>
List<TagCountJson> GetTagList(string accessToken);
/// <summary>
/// 编辑标签
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="id">标签ID</param>
/// <param name="name">标签名称</param>
/// <returns></returns>
CommonResult UpdateTag(string accessToken, int id, string name);
/// <summary>
/// 删除标签
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="id">标签ID</param>
/// <returns></returns>
CommonResult DeleteTag(string accessToken, int id);
/// <summary>
/// 获取标签下粉丝列表
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="id">标签ID</param>
/// <param name="name">标签名称</param>
/// <returns></returns>
GetTagResult GetTag(string accessToken, int id, string next_openid = null);
/// <summary>
/// 批量为用户打标签
/// 标签功能目前支持公众号为用户打上最多三个标签。
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="tagid">标签ID</param>
/// <param name="openid_list">粉丝列表</param>
/// <returns></returns>
CommonResult BatchTagging(string accessToken, int tagid, List<string> openid_list);
/// <summary>
/// 批量为用户取消标签
/// 标签功能目前支持公众号为用户打上最多三个标签。
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="tagid">标签ID</param>
/// <param name="openid_list">粉丝列表</param>
/// <returns></returns>
CommonResult BatchUntagging(string accessToken, int tagid, List<string> openid_list);
/// <summary>
/// 获取用户身上的标签列表
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="openid">用户OpenID</param>
/// <returns></returns>
List<int> GetIdList(string accessToken, string openid);
}

Jetons un coup d'œil aux données de définition officielles de plusieurs interfaces.

1) Interface de création de balises

Description de la demande d'appel de l'interface

Méthode de requête http : POST (veuillez utiliser le protocole https)

https://api.weixin.qq.com/cgi-bin/tags/create?access_token=ACCESS_TOKEN

Format de données POST : JSON

Exemple de données POST :

{
"tag" : {
"name" : "广东"//标签名
}
}

Description du retour (exemple de paquet de données json renvoyé normalement)

{
"tag":{
"id":134,//标签id
"name":"广东"
}
}

De cette façon, nous pouvons définir une classe d'entité pour transporter les données renvoyées.

/// <summary>
/// 标签信息
/// </summary>
public class TagJson
{
/// <summary>
/// 标签id，由微信分配
/// </summary>
public int id { get; set; }
/// <summary>
/// 标签名，UTF8编码
/// </summary>
public string name { get; set; }
}

De cette façon, le code d'implémentation complet pour la création de balises est le suivant

/// <summary>
/// 创建标签
/// 一个公众号，最多可以创建100个标签。
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="name">标签名（30个字符以内）</param>
/// <returns></returns>
public TagJson CreateTag(string accessToken, string name)
{
var url = string.Format("https://api.weixin.qq.com/cgi-bin/tags/create?access_token={0}", accessToken);
var data = new
{
tag = new
{
name = name
}
};
var postData = data.ToJson();
var result = JsonHelper<TagCreateResult>.ConvertJson(url, postData);
return result != null ? result.tag : null;
}

2) Obtenez les tags créés par le compte officiel

Instructions de demande d'appel d'interface

Méthode de requête http : GET (veuillez utiliser le protocole https)

https://api.weixin.qq.com/cgi-bin/tags/get?access_token=ACCESS_TOKEN

Format des données de retour : JSON Exemple de données renvoyées :

{
"tags":[{
"id":1,
"name":"黑名单",
"count":0 //此标签下粉丝数
},{
"id":2,
"name":"星标组",
"count":0
},{
"id":127,
"name":"广东",
"count":5
}
]
}

De cette façon, nous pouvons définir sa valeur de retour comme List, où TagCountJson est un attribut de la classe correspondante.

/// <summary>
/// 标签信息和统计数量
/// </summary>
public class TagCountJson : TagJson
{
/// <summary>
/// 此标签下粉丝数
/// </summary>
public int count { get; set; }
}

De cette façon, nous pouvons renvoyer les données correspondantes via l'analyse JSON. Les opérations associées sont similaires à l'interface ci-dessus et ne seront pas décrites en détail.

Pour plus d'articles liés à la fonction de gestion des balises de compte public WeChat développée par C# WeChat, veuillez faire attention au site Web PHP chinois !