Pour des raisons historiques, mon importateur Google+ a importé les utilisateurs au niveau de confiance 1 (TL1) pour donner un coup de pouce aux réfugiés de Google+. Ils sont importés avec des adresses e-mail .invalid, et nous corrigeons cela lorsqu’ils se connectent et sont associés à leur enregistrement d’utilisateur existant par leur identifiant Google via l’authentification Google.
Mais maintenant, mon groupe trust_level_1 est surchargé de milliers d’utilisateurs qui n’ont pas encore suivi leur contenu, et s’ils apparaissent après quelques années (comme cela arrive parfois), il n’y a aucune raison particulière pour qu’ils arrivent en tant qu’utilisateurs de base ; ils devraient être de nouveaux utilisateurs. Le démarrage est terminé depuis longtemps. Je voudrais rétrograder ces utilisateurs qui ne se sont jamais connectés au niveau 0 (TL0) jusqu’à ce qu’ils apparaissent et jettent un œil, et simplement dépendre du processus de promotion normal.
J’ai essayé ceci dans la console Rails :
User.where(trust_level: 1) do |u|
u.change_trust_level!(TrustLevel[0]) if !Email.is_valid?(u.primary_email&.email)
u.save!
end
Cela a pris des minutes à consommer un CPU complet, mais n’a rien fait. (J’ai essayé d’autres variations en cours de route, comme if !u.primary_email.is_valid? et if !Email.is_valid?(u.primary_email) et je sais que le vrai problème est que je touche au Ruby une fois par an environ…) Je suis sûr qu’il me manque quelque chose d’évident pour les autres. J’apprécierais un indice si quelqu’un peut en trouver un !
User.where(trust_level: 1).each do |u|
u.change_trust_level!(TrustLevel[0]) if !Email.is_valid?(u.primary_email&.email)
u.save!
end
Cela a fait planter mon site pendant son exécution avec beaucoup d’E/S et n’a toujours apporté aucune modification. Je fais donc toujours quelque chose de mal et je ne suis pas peu inquiet de continuer à essayer cela sur le système en direct.
J’ai compris que ce n’est pas ce que signifie is_valid?. Je cherche donc maintenant la chaîne littérale à la place, et je l’ai testée en imprimant l’adresse e-mail. Je vois aussi que change_trust_level enregistre déjà l’utilisateur, donc je n’ai pas besoin de le faire deux fois.
User.where(trust_level: 1).each do |u|
if u.primary_email&.email.end_with?(".invalid")
u.change_trust_level!(TrustLevel[0])
end
end
Mais le nombre d’utilisateurs dans trust_level_1 ne change toujours pas, donc il me manque toujours quelque chose d’important.
Pourriez-vous utiliser la tâche d’administration en bloc dans ce cas ?
Bien que je viens de tester votre deuxième code et qu’il ait fonctionné pour moi sur mon utilisateur de test (e-mail : test_thirteen@here.invalid, était TL1 et est maintenant TL0).
User.where(trust_level: 1).each do |u|
if u.primary_email&.email.end_with?(".invalid")
u.change_trust_level!(TrustLevel[0])
end
end
Je commencerais par le modèle UserEmail et je trouverais ceux qui ont « invalid » dans leur adresse e-mail et je parcourrais ceux-là, mais ce n’est pas quelque chose que je peux déterminer exactement sur mon téléphone.
Si ces adresses contenant « invalid » étaient vraiment invalides, elles ne pourraient pas être enregistrées.
J’ai promu manuellement certains utilisateurs qui étaient auparavant bien connus des membres existants de la communauté, donc un recalcul en masse n’aurait pas fait ce que je voulais. (J’avais trouvé cette page en cherchant.)
Ce dernier fonctionnait en fait, comme pour vous. Mon problème était que je regardais la page d’aperçu des groupes /g et que je la rafraîchissais en cherchant à diminuer le nombre de membres du groupe trust_level_1. Il n’affichait pas de changement de nombre pendant que je l’exécutais, alors je l’ai arrêté avec control-C. Ce matin, le groupe trust_level_1 a maintenant des milliers de membres en moins affichés sur cette page. J’ai donc réalisé que le nombre y était mis en cache, et j’aurais dû cliquer sur cette carte et regarder le nombre sur la page /g/trust_level_1.
Je comprends maintenant que j’aurais dû suivre avec Group.ensure_consistency! pour réparer les décomptes sur cette page.
Voici l’ensemble, exprimé de manière plus compacte et idiomatique :
User.where(trust_level: 1).each do |u|
u.change_trust_level!(TrustLevel[0]) if u.primary_email&.email.end_with?(".invalid")
end
Group.ensure_consistency!
Il se trouve que j’ai un enregistrement de quelques utilisateurs avec seulement un e-mail invalide qui ont utilisé le site et rempli les conditions du TL1. Je ne sais pas comment cela est arrivé, mais pour l’instant, je m’en fiche. Tout ce qui m’importe, c’est de m’occuper de la masse de milliers, sans me soucier des quelques exceptions. Si cela arrive à quelqu’un d’autre, voici ce qui a fonctionné pour moi :
User.where(trust_level: 1).each do |u|
begin
u.change_trust_level!(TrustLevel[0]) if u.primary_email&.email.end_with?(".invalid")
rescue
end
end
Group.ensure_consistency!
def import_google_user(id, name)
if !@emails[id].present?
google_user_info = UserAssociatedAccount.find_by(provider_name: 'google_oauth2', provider_u
id: id.to_i)
if google_user_info.nil?
# créer un nouvel utilisateur Google sur le système ; on s'attend à ce que cet utilisateur fusionne
# lorsqu'il se connectera plus tard avec l'authentification Google
# Notez que comme l'adresse e-mail n'est pas incluse dans les données G+, nous
# ne savons pas s'ils ont déjà un autre compte non encore associé
# à google ooauth2. S'ils ne se connectaient pas, ils auront une adresse
# @gplus.invalid associée à leur compte
email = "#{id}@gplus.invalid"
Cela signifie que je ne me soucie que de primary_email et que je n’ai pas à commencer par UserEmail. J’ai commencé dans cette voie avant de réaliser que tout ce qui changerait cela pour ne plus être le primary_email me ferait ne pas vouloir les changer de toute façon. Donc, ici, il s’agit très spécifiquement des utilisateurs dont le seul (donc primaire) e-mail se termine littéralement par .invalid — ce que j’ai fait.
