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>
/// 设置值
/// </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>
/// 清空所有项
/// </summary>
public static void Clear()
{
mDic.Clear();
}
}Copier après la connexion
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>
/// 认证
/// </summary>
Auth,
/// <summary>
/// 添加用户
/// </summary>
CreateUser
}Copier après la connexion
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>
/// 默认
/// </summary>
Default,
/// <summary>
/// 第一步
/// </summary>
First,
/// <summary>
/// 第二步
/// </summary>
Second,
/// <summary>
/// 第三步
/// </summary>
Third
}Copier après la connexion
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>
/// 当前步骤
/// </summary>
public OperationStage Stage { get; set; }
/// <summary>
/// 数据对象
/// </summary>
public object Data { get; set; }
/// <summary>
/// 是否自动删除
/// </summary>
public bool AutoRemove
{
get;
set;
}
/// <summary>
/// 最后更新时间
/// </summary>
public DateTime UpdateTime { get; set; }
}Copier après la connexion
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>
/// 账号
/// </summary>
public string Code { get; set; }
/// <summary>
/// 唯一标识
/// </summary>
public string ID { get; set; }
}Copier après la connexion
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>
/// 认证用户信息
/// </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))
{
//检查是否已经认证,业务组件验证
if (UserManager.IsAuth(tm.FromUserName))
{
//如果已经认证，提示
tm.Content = "您已经认证过了，无需再次认证！";
}
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);
//输入账号，并将数据和步骤，写入缓存
tm.Content = "请输入您的个人账号";
}
response = ResponseText(tm);
return false;
}
//从Session获取用户信息
sessionItem = Session.Get(tm.FromUserName) as SessionItem;
//如果会话存在，且当前操作为用户认证
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 = "输入的个人账号不合法，请重新输入。";
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 = "请输入您的员工卡号！\n退出认证请输入Exit。";
response = ResponseText(tm);
}
else if (sessionItem.Stage == OperationStage.Second)
{
string cardNum = null;
if (!Common.TryConvertToCardNum(tm.Content, out cardNum))
{
tm.Content = "员工卡号不合法,请重新输入。\n退出认证请输入Exit。";
response = ResponseText(tm);
return false;
}
AuthSessionItem authSessionItem = sessionItem.Data as AuthSessionItem;
if (authSessionItem != null)
{
authSessionItem.ID = cardNum;
}
//认证
string message;
if (UserManager.Authenticate(authSessionItem, out message))
{
tm.Content = "祝贺您，已经认证成功，可以使用通讯录的查询功能呢。";
//清理缓存
Session.Remove(tm.FromUserName);
response = ResponseText(tm);
return true;
}
else if (!string.IsNullOrEmpty(message))
{
tm.Content = message;
}
else
{
tm.Content = "您输入的信息有误。\n重新认证请输入：Auth!";
}
//过程结束：清理Session
Session.Remove(tm.FromUserName);
response = ResponseText(tm);
return false;
}
}
return false;
}Copier après la connexion
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 = "您已退出当前操作，请执行其他操作。";
response = ResponseText(tm);
return true;
}
return false;
}Copier après la connexion
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
Grâce à cette méthode, les comptes publics peuvent réaliser des applications métiers de plus en plus complexes grâce à 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 !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
