Django a implémenté une fonction de suivi qui est presque essentielle pour les applications SNS. Ce sera une auto-implémentation qui n'utilise pas la bibliothèque. Personnalisez-le en fonction de vos besoins et exigences.
La liste des abonnés est omise ici. Mettre en œuvre les exigences fonctionnelles minimales requises.
Il existe un moyen de créer une seule table, mais j'ai personnellement l'impression que l'instruction SQL devient redondante et qu'il est difficile de gérer la table, je vais donc en préparer deux cette fois.
** table follow_relation **
| Les données | Informations à stocker | Type de données |
|---|---|---|
| user_id | ID utilisateur de l'abonné | UUID |
| followed_id | ID utilisateur de la personne suivie | UUID |
** table follow_count **
| Les données | Informations à stocker | Les données型 |
|---|---|---|
| user_id | Identifiant d'utilisateur | UUID |
| follow | Nombre d'abonnés | INT |
| followed | Numéro suivi | INT |
La table follow_relation gère le statut de suivi entre les utilisateurs, et la table follow_count gère le nombre d'adeptes et d'adeptes des utilisateurs.
Implémentons la fonction suivante dès que la table est créée. Le flux général de la fonction de suivi est le suivant.
Demande de page
↓
followd_Vérifier et afficher l'état de suivi avec la fonction d'état
↓
Appuyez sur le bouton de suivi
↓
La fonction suivante traite selon le statut suivant
↓
Revenir à la page d'origine
Ensuite, il devient le code suivant.
followed_fonction d'état
@login_required
def followed_status(request, accesskey):
#réduction
#Obtenez les paramètres dont vous avez besoin
#Se connecter à la base de données
connection = MySQLdb.connect(
host='localhost',
user='***',
passwd='***',
db='***',
charset="utf8"
)
#Récupérez le curseur
cursor = connection.cursor()
#Ensemble de requêtes
follow_relation = "SELECT COUNT(*) FROM follow_relation where user_id = UUID_TO_BIN(%s) and followed_id = UUID_TO_BIN(%s);"
#Exécuter l'ordre
# user_id、followed_Obtenez votre identité par vous-même
cursor.execute(follow_relation, (user_id, followed_id))
row_follow = cursor.fetchone()
follows = row_follow[0]
#Déterminer si l'utilisateur de connexion et l'utilisateur de la page sont la même personne
#Assurez-vous que vous ne pouvez pas suivre la même personne
if followed_id == user_id:
followed_status_code = 1
else:
followed_status_code = 2
#Vrai si suit est supérieur à 0
#Renvoie False si suit est 0
followed = False
if follows > 0 :
followed = True
return followed_status_code, followed
Veuillez extraire les paramètres requis de votre propre tableau.
Tout ce dont vous avez besoin cette fois est l'ID du suiveur et du suiveur.
Le côté que suit user_id et le côté qui suit_id suit.
Donnez un code de statut pour déterminer s'il s'agit de la même personne.
Si follow_status_code = 1, alors vous-même (ne pouvez pas suivre)
Si follow_status_code = 2, autres (vous pouvez suivre)
Sera.
--Vérifiez l'état de suivi
Vérifiez l'état de suivi avec Vrai et Faux.
Si c'est "Faux", je ne l'ai pas encore suivi Si "True", vous suivez déjà
Sera. Regardons maintenant la fonction suivante.
suit la fonction
@login_required
def followes(request, accesskey):
#réduction
#Obtenez les paramètres dont vous avez besoin
#Se connecter à la base de données
connection = MySQLdb.connect(
host='localhost',
user='***',
passwd='***',
db='***',
charset="utf8"
)
#Récupérez le curseur
cursor = connection.cursor()
#Veuillez définir une requête commune
#Obtenez les informations dont vous avez besoin ici
#Empêchez-vous de suivre
if user_id == followed_id:
followed = False
#Enregistrer l'état de suivi dans la session
request.session['page_followed_status'] = followed
else:
if followed == False:
#Ce sera le processus en suivant
#Ensemble de requêtes
#Insérer une nouvelle relation de suivi
follow_reation = "INSERT INTO follow_relation (user_id, followed_id) values(UUID_TO_BIN(%s), UUID_TO_BIN(%s));"
#Augmentez de un le nombre d'abonnés
follow_update = "UPDATE follow_count SET follow = follow + 1 where user_id=UUID_TO_BIN(%s);"
#Augmentez le nombre d'abonnés de l'utilisateur suivi d'un
followed_update = "UPDATE follow_count SET followed = followed + 1 where user_id=UUID_TO_BIN(%s);"
#Exécuter l'ordre
cursor.execute(follow_relation, (user_id, followed_id))
cursor.execute(follow_update, (user_id, ))
cursor.execute(followed_update, (followed_id, ))
#Fermer la connexion
cursor.close()
connection.commit()
connection.close()
#Faites-le suivre
followed = True
request.session['page_followed_status'] = followed
else:
#Ce sera le processus lors du désabonnement
#Ensemble de requêtes
#Supprimer la relation de suivi
follow_relation = "DELETE FROM follow_relation where user_id=UUID_TO_BIN(%s) and followed_id = UUID_TO_BIN(%s);"
#Réduisez de un le nombre d'utilisateurs non suivis
follow_update = "UPDATE follow_count SET follow = follow - 1 where user_id=UUID_TO_BIN(%s);"
#Réduisez de un le nombre d'abonnés des utilisateurs de pages non suivis
followed_update = "UPDATE follow_count SET followed = followed - 1 where user_id=UUID_TO_BIN(%s);"
#Exécuter l'ordre
cursor.execute(sql_followrelation_delete, (user_id, followed_id))
cursor.execute(sql_follow_update, (user_id, ))
cursor.execute(sql_followed_update, (followed_id, ))
#Fermer la connexion
cursor.close()
connection.commit()
connection.close()
#Rendre le non suivi
followed = False
request.session['page_followed_status'] = followed
return redirect('Page originale', accesskey)
Il s'agit du traitement réel du branchement avec une instruction if et suivant ou non suivi. Et enfin, le statut de suivi est changé. Redirigez vers la page d'origine et terminez. (Cette fois, la transition de page se produit car Ajax etc. n'est pas utilisé)
Enfin, modifiez la vue à afficher.
fonction résultat
@login_required
def result(request, accesskey):
#réduction
#Comprendre le statut du suivi
status = followed_status(request, accesskey)
followed_status_code = status[0]
followed = status[1]
#Enregistrer l'état de suivi dans la session (temporaire)
request.session['page_followed_status'] = followed
params = {
#réduction
'page_followed_status': followed,
'page_followed_status_code': followed_status_code,
}
return render(request, 'result.html', params)
Seules les pièces pertinentes sont répertoriées.
Nous vérifions le statut de suivi en appelant la fonction follow_status.
(La fonction follow_status renvoie le code d'état et suit l'état.)
Et je l'enregistre temporairement dans la session.
urls.py
urlpatterns = [
#réduction
path('Page originale', views.pages, name='Défini par vous-même'),
path('Page originale/follow/', views.follows, name="follows"),
#réduction
]
Enfin, il existe un modèle.
result.html
<!--Ajouter un bouton de suivi-->
{% if page_followed_status_code is 2 %}
{% if page_followed_status is False %}
<p><a href="{% url 'follows' page_accesskey %}">Suivre</a></p>
{% else %}
<p><a href="{% url 'follows' page_accesskey %}">Arrêter de suivre</a></p>
{% endif %}
{% endif %}
Il ne s'affiche que lorsque le code d'état est 2 (lorsqu'il est entre autres, pas vous-même).
Et si le statut de suivi est "False", il est affiché comme "Follow", et quand il est "True", il est affiché comme "Arrêter de suivre".
Lorsque le lien est enfoncé, la fonction suivante est appelée à la destination de la page, le processus de suivi est exécuté et la page est redirigée vers la page d'origine.
Veuillez modifier le code et l'utiliser à votre manière. La fonction "J'aime" peut être implémentée de la même manière!
Recommended Posts