Dans la fenêtre WeChat, les informations de saisie sont limitées et nous devons demander certaines informations plusieurs fois.

Par exemple?: lors de la liaison des utilisateurs, nous devons saisir des informations pertinentes sur l'utilisateur, telles que?: le nom d'utilisateur, le mot de passe ou le nom, le numéro de téléphone et si le c?té serveur est vérifié , les utilisateurs du système sont liés aux utilisateurs de WeChat.

Ensuite, ce compte WeChat disposera de certaines autorisations fonctionnelles, et vous pourrez vérifier les points, les enregistrements de consommation, etc. Compte de service?: la carte de crédit de la China Merchants Bank a de nombreuses fonctions.

Le client WeChat ne peut pas mettre en cache les informations et les informations saisies sont limitées. Plusieurs requêtes sont nécessaires pour enregistrer l'état de la session actuelle sur le serveur. Cela nécessite une session.

Cet article prend l'authentification des utilisateurs et la liaison de compte comme exemple pour illustrer le traitement spécifique.

1. Créez un mécanisme de traitement de session universel.

Afin de mieux expliquer le principe et faciliter l'expansion, nous concevrons nous-mêmes la Session. Bien entendu, System.Web.SessionState.HttpSessionState peut également être utilisé ici, qui est un mécanisme de session couramment utilisé sur le Web.

1. La session personnalisée

est utilisée pour stocker des fragments de session et des données associées.

class Session
    {
        /// <summary>
        /// 緩存hashtable
        /// </summary>
        private static Hashtable mDic = new Hashtable();
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        public static void Add(string key, object value)
        {
            mDic[key] = value;
        }
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="key">key</param>
        public static void Remove(string key)
        {
            if (Contains(key))
            {
                mDic.Remove(key);
            }
        }
        /// <summary>
        /// 設(shè)置值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void Set(string key, object value)
        {
            mDic[key] = value;
        }
        /// <summary>
        /// 獲取值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static object Get(string key)
        {
            return mDic[key];
        }
        /// <summary>
        /// 是否含有
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>bool</returns>
        public static bool Contains(string key)
        {
            return mDic.ContainsKey(key);
        }
        /// <summary>
        /// 清空所有項(xiàng)
        /// </summary>
        public static void Clear()
        {
            mDic.Clear();
        }
    }

2. Type d'opération

Enregistrez le type d'opération spécifique et identifiez l'opération spécifique de la session en cours

/// <summary>
    /// 操作類型
    /// </summary>
    enum Operation
    {
        /// <summary>
        /// 認(rèn)證
        /// </summary>
        Auth,
        /// <summary>
        /// 添加用戶
        /// </summary>
        CreateUser
    }

3. L'énumération du processus d'opération

est utilisée pour identifier l'opération en cours et à quelle étape elle se trouve. Différentes étapes effectuent différents traitements.

/// <summary>
    /// 操作過程
    /// </summary>
    enum OperationStage
    {
        /// <summary>
        /// 默認(rèn)
        /// </summary>
        Default,
        /// <summary>
        /// 第一步
        /// </summary>
        First,
        /// <summary>
        /// 第二步
        /// </summary>
        Second,
        /// <summary>
        /// 第三步
        /// </summary>
        Third
    }

4. éléments du cache de session

Cache les éléments enregistrés, qui enregistrent le type d'opération, les étapes de l'opération et les objets de session. Afin de faciliter la gestion des sessions, l'heure du dernier accès et l'effacement automatique du logo sont également ajoutés.

class SessionItem
    {
        /// <summary>
        /// 操作類型
        /// </summary>
        public Operation Oper { get; set; }
        /// <summary>
        /// 當(dāng)前步驟
        /// </summary>
        public OperationStage Stage { get; set; }
        /// <summary>
        /// 數(shù)據(jù)對(duì)象
        /// </summary>
        public object Data { get; set; }
        /// <summary>
        /// 是否自動(dòng)刪除
        /// </summary>
        public bool AutoRemove
        {
            get;
            set;
        }
        /// <summary>
        /// 最后更新時(shí)間
        /// </summary>
        public DateTime UpdateTime { get; set; }
    }

Deuxièmement, nous devons ajouter le traitement de session au traitement des messages.

1. Ajouter un objet de données d'élément de cache

Cet objet enregistre les informations pertinentes saisies par l'utilisateur au cours de la session. Il est également utilisé comme objet pour le traitement des données commerciales.

class AuthSessionItem
    {
        /// <summary>
        /// 用戶名
        /// </summary>
        public string FromUserName { get; set; }
        /// <summary>
        /// 賬號(hào)
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 唯一標(biāo)識(shí)
        /// </summary>
        public string ID { get; set; }
    }

2. Processus d'authentification

1) Commencez à saisir l'authentification et marquez en fonction de l'authentification. mot-clé, démarrez la session et mettez en cache les données pertinentes

2) Invite à saisir les informations du compte personnel

3) Les utilisateurs de WeChat saisissent leur compte personnel, le serveur enregistre les informations du compte et invite à saisir l'employé numéro de carte

4) L'utilisateur WeChat saisit les informations du numéro de carte, le serveur enregistre les informations du numéro de carte et appelle la logique d'authentification spécifique

5) L'utilisateur réussit l'authentification, lie le WeChat OpenId, demande des informations de liaison réussies et efface la session.

Pendant le processus d'authentification, la légalité des informations saisies par l'utilisateur doit être vérifiée et pendant la session, les utilisateurs sont aidés à quitter l'opération en cours.

/// <summary>
        /// 認(rèn)證用戶信息
        /// </summary>
        /// <param name="tm"></param>
        /// <returns></returns>
        private bool Auth(TextMessage tm, ref string response)
        {
            SessionItem sessionItem = null;
            if (string.Equals(tm.Content, "Auth", StringComparison.OrdinalIgnoreCase))
            {
                //檢查是否已經(jīng)認(rèn)證,業(yè)務(wù)組件驗(yàn)證
                if (UserManager.IsAuth(tm.FromUserName))
                {
                    //如果已經(jīng)認(rèn)證，提示
                    tm.Content = "您已經(jīng)認(rèn)證過了，無(wú)需再次認(rèn)證！";                    
                }
                else
                {
                    AuthSessionItem authSessionItem = new AuthSessionItem();
                    authSessionItem.FromUserName = tm.FromUserName;

                    sessionItem.Oper = Operation.Auth;
                    sessionItem.Stage = OperationStage.First;
                    sessionItem.Data = authSessionItem;
                    Session.Set(tm.FromUserName, sessionItem);

                    //輸入賬號(hào)，并將數(shù)據(jù)和步驟，寫入緩存
                    tm.Content = "請(qǐng)輸入您的個(gè)人賬號(hào)";
                }

                response = ResponseText(tm);
                return false;
            }

            //從Session獲取用戶信息
            sessionItem = Session.Get(tm.FromUserName) as SessionItem;
            //如果會(huì)話存在，且當(dāng)前操作為用戶認(rèn)證
            if (sessionItem != null && sessionItem.Oper == Operation.Auth)
            {
                if (sessionItem.Stage == OperationStage.First)
                {
                    tm.Content = tm.Content.Trim();
                    if (string.IsNullOrEmpty(tm.Content) || tm.Content.Length > 20)
                    {
                        tm.Content = "輸入的個(gè)人賬號(hào)不合法，請(qǐng)重新輸入。";
                        response = ResponseText(tm);
                        return false;
                    }
                    AuthSessionItem authSessionItem = sessionItem.Data as AuthSessionItem;
                    if (authSessionItem != null)
                    {
                        authSessionItem.Code = tm.Content;
                    }

                    //更新緩存
                    sessionItem.Stage = OperationStage.Second;
                    Session.Set(tm.FromUserName, sessionItem);
                    tm.Content = "請(qǐng)輸入您的員工卡號(hào)！\n退出認(rèn)證請(qǐng)輸入Exit。";
                    response = ResponseText(tm);  
                }
                else if (sessionItem.Stage == OperationStage.Second)
                {
                    string cardNum = null;
                    if (!Common.TryConvertToCardNum(tm.Content, out cardNum))
                    {                       
                        tm.Content = "員工卡號(hào)不合法,請(qǐng)重新輸入。\n退出認(rèn)證請(qǐng)輸入Exit。";
                        response = ResponseText(tm);
                        return false;
                    }
                    AuthSessionItem authSessionItem = sessionItem.Data as AuthSessionItem;
                    if (authSessionItem != null)
                    {
                        authSessionItem.ID = cardNum;
                    }
                    //認(rèn)證
                    string message;
                    if (UserManager.Authenticate(authSessionItem, out message))
                    {
                        tm.Content = "祝賀您，已經(jīng)認(rèn)證成功，可以使用通訊錄的查詢功能呢。";
                        //清理緩存
                        Session.Remove(tm.FromUserName);
                        response = ResponseText(tm);
                        return true;
                    }
                    else if (!string.IsNullOrEmpty(message))
                    {
                        tm.Content = message;
                    }
                    else
                    {
                        tm.Content = "您輸入的信息有誤。\n重新認(rèn)證請(qǐng)輸入：Auth!";
                    }
                    //過程結(jié)束：清理Session
                    Session.Remove(tm.FromUserName);
                    response = ResponseText(tm);
                    return false;
                }
            }

            return false;
        }

3. Quittez la session et nettoyez la session

Pendant le processus d'authentification, l'utilisateur peut quitter de force l'opération en cours. via des commandes Lorsque vous quittez l’opération en cours, les informations de session doivent être effacées.

/// <summary>
        /// 退出，并清理Session
        /// </summary>
        /// <param name="tm"></param>
        /// <param name="response"></param>
        /// <returns></returns>
        private bool Exit(TextMessage tm, ref string response)
        {
            //退出
            if (string.Equals(tm.Content, "Exit", StringComparison.OrdinalIgnoreCase))
            {
                //清除Session
                Session.Remove(tm.FromUserName);
                tm.Content = "您已退出當(dāng)前操作，請(qǐng)執(zhí)行其他操作。";
                response = ResponseText(tm);
                return true;
            }

            return false;
        }

3. Authentification de l'utilisateur réussie, liez le compte WeChat

Authentification de l'utilisateur réussie et liez WeChat OpenId, via OpenId c'est-à-dire vous pouvez désormais consulter votre carnet d'adresses, vos points personnels et vos relevés de consommation. L'authentification de l'utilisateur est un processus d'authentification d'identité et un processus de liaison d'utilisateur. Si l'identité de l'utilisateur est authentifiée, vous pouvez demander des informations spécifiques via votre compte WeChat. à ce stade, la couche métier peut directement interroger les informations relatives à l'utilisateur en fonction de l'OpenId attribué par WeChat.

4. Postscript

Grace à cette méthode, les comptes publics peuvent réaliser des applications métiers de plus en plus complexes grace à de petites zones de saisie de texte. Bien entendu, il est plus intuitif et plus pratique de saisir des informations en fournissant une page Web.

Pour plus d'articles liés au développement de la plateforme publique WeChat et au traitement des sessions, veuillez faire attention au site Web PHP chinois?!