C#-Entwicklung des WeChat-Portals und der WeChat-Anwendung (5) – Benutzergruppen-Informationsmanagement

Letzten Monat habe ich die Entwicklung von WeChat-Portalen und -Anwendungen in C# vorgestellt und mehrere Aufsätze zum Teilen geschrieben. Aus Zeitgründen habe ich diese Blogreihe eine Weile nicht weitergeschrieben. Wir haben nicht aufgehört zu recherchieren. Um die Technologie in diesem Bereich jedoch weiter eingehend zu erforschen, konzentrierten wir uns auf die Entwicklung der zugrunde liegenden Technologie. Dieser Artikel setzt die Einführung des vorherigen Artikels fort und stellt hauptsächlich die Entwicklung und Anwendung des Gruppenmanagements vor. Der Inhalt dieses Artikels und des vorherigen Artikels dient als vollständige Kombination aus Benutzerinformations- und Gruppeninformationsmanagement.

1. Benutzergruppenverwaltungsinhalte

Die Einführung von Benutzergruppen dient hauptsächlich dazu, die Verwaltung von Followerlisten und den Vorgang des Sendens von Nachrichten an verschiedene Gruppen zu erleichtern Gruppen.

Die Benutzergruppenverwaltung umfasst die folgenden Aspekte:

1 Eine Gruppe erstellen
2 Alle Gruppen abfragen
3 Die Gruppe abfragen, zu der der Benutzer gehört
4 Den Gruppennamen ändern
5 mobile Benutzergruppen

WeChat definiert die Erstellung von Gruppen wie folgt.

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

Das normalerweise zurückgegebene Ergebnis ist wie folgt.

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

Andere Schnittstellen funktionieren auf ähnliche Weise, indem sie einige Parameter in die URL POSTEN, um die zurückgegebenen Json-Daten zu erhalten.

Die im vorherigen Aufsatz definierten Entitätsklasseninformationen von GroupJson lauten wie folgt.

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

Basierend auf den Definitionen der oben genannten Schnittstellen habe ich mehrere Schnittstellen definiert und sie in der Benutzerverwaltungs-API-Schnittstelle zusammengefasst.

        /// <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. Implementierung der Benutzergruppenverwaltungsoberfläche

2.1 Benutzer erstellen Gruppe

Um zu analysieren, wie der POST-Datenvorgang zum Erstellen von Benutzergruppen implementiert wird, wollen wir den spezifischen Prozess zum Erstellen von Benutzern Schritt für Schritt verstehen.

Zuerst müssen Sie eine dynamisch definierte Entitätsklasseninformation erstellen, die mehrere Attribute enthält, die erwähnt werden müssen, wie unten gezeigt.

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

Unter anderem konvertieren wir das Objekt in eine geeignete Json-Datenoperation und fügen es in die Erweiterungsmethode ToJson ein. Dies dient hauptsächlich der dynamischen Erleichterung Definierte Entitäten. Die Klassenkonvertierung von Json-Inhalten umfasst hauptsächlich den Aufruf der Seriennummernoperation von Json.NET.

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

Nach der Vorbereitung der Post-Daten schauen wir uns den Operationscode genauer an, um die Daten zu erhalten und in ein geeignetes Format zu konvertieren.

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

Die Operation von POST-Daten und deren Konvertierung in eine geeignete Format-Entitätsklasse wird in der ConvertJson-Methode platziert. Die Definition dieser Methode lautet wie folgt Innerhalb von HttpHelper handelt es sich um eine Hilfsklasse meiner öffentlichen Klassenbibliothek. Sie ruft hauptsächlich die zugrunde liegende httpWebRequest-Objektmethode auf, um Daten zu übermitteln und das Rückgabeergebnis zu erhalten.

        /// <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;
        }

Auf diese Weise ist die vollständige Betriebsfunktion zum Erstellen von Benutzergruppen wie folgt.

        /// 

        /// 创建分组        /// 
        /// 调用接口凭证
        /// 分组名称
        /// 
        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 Alle Gruppen abfragen

Alle Gruppen abfragen, Sie können alle Gruppen auf dem Server abrufen , also die ID und der Name jeder Gruppe.

        /// <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 Fragen Sie die Gruppe ab, zu der der Benutzer gehört

Jeder Benutzer gehört zu einer Gruppe, die Standardeinstellung ist Ungrouped In dieser Gruppe können wir die Gruppeninformationen des Benutzers über die API abrufen, dh die ID der Benutzergruppe.

        /// <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 Ändern des Gruppennamens

Sie können auch die Gruppe anpassen, in der sich der Benutzer in der Praxis befindet . Der Code lautet wie folgt.

        /// <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);
        }

Der Rückgabewert CommonResult ist hier eine Entitätsklasse, die ein Bool-Flag für Erfolg oder Misserfolg und eine Fehlermeldung vom Typ String (falls vorhanden) enthält beliebig).

Beim GetExecuteResult-Funktionskörper handelt es sich hauptsächlich um eine Funktion, die Daten übermittelt, dann die Ergebnisse abruft und sie basierend auf den Ergebnissen verarbeitet.

        /// <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;
        }  
    }

Die Bedeutung des roten Teils oben ist, dass bei der Konvertierung in eine Entitätsklasse, wenn der Fehler in WeChat definiert ist, die Fehlermeldung und Andere Ausnahmen werden aufgezeichnet. Ich kümmere mich nicht darum (also wegwerfen).

2.5 Verschieben eines Benutzers in eine neue Gruppe

Der Vorgang zum Verschieben eines Benutzers in eine neue Gruppe ähnelt dem obigen Abschnitt. Einzelheiten finden Sie im Code.

        /// <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. Aufruf der Benutzergruppierungsschnittstelle

Der obige Abschnitt definiert und implementiert die Benutzergruppierung. Verschiedene Schnittstellen und alle benutzerbezogenen Codes wurden ohne Vorbehalt veröffentlicht. Der Aufrufvorgang wird im folgenden Code (Testcode) gezeigt.

        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));
            }
        }

Nachdem wir den obigen Code und die Aufrufregeln verstanden haben, können wir Benutzergruppeninformationen über die API verwalten. Durch die Integration relevanter Schnittstellencodes in die Anwendung können wir eine gute Kontrolle über unsere folgenden Benutzerlisten- und Benutzergruppeninformationen haben. Dies wird eine solide Grundlage für unseren nächsten Push an Benutzerinformationen legen.

Weitere Informationen zur C#-Entwicklung von WeChat-Portalen und -Anwendungen (5) – Verwaltung von Benutzergruppeninformationen finden Sie auf der chinesischen PHP-Website für verwandte Artikel!