stream rails
v3.1.0
stream-rails est un client Ruby on Rails pour Stream.
Vous pouvez créer un compte Stream sur https://getstream.io/get_started.
Notez qu'il existe également une bibliothèque d'intégration Ruby - Stream de niveau inférieur qui convient à toutes les applications Ruby.
Il s'agit d'une bibliothèque pour le produit Feeds . Les SDK Chat peuvent être trouvés ici.
Ce que vous pouvez construire :
Flux d'activité tels que ceux vus sur Github
Un fil d'actualité façon Twitter
Un flux comme Instagram/Pinterest
Fils d'actualité de style Facebook
Un système de notifications
Vous pouvez consulter notre exemple d'application créée à l'aide de cette bibliothèque sur Github https://github.com/GetStream/Stream-Example-Rails
Flux d'activités et flux d'actualités
Démo
Table des matières
Installation de gemmes
Installation
ORM pris en charge
Enregistrement actif
Suite
Configuration du modèle
Champs d'activité
Données supplémentaires d'activité
Création d'activité
Gestionnaire de flux
Flux utilisateur :
Fils d'actualité :
Flux de notifications :
Flux fournis avec feed_manager
Suivre un flux
Afficher le fil d'actualité
Enrichissement de l'activité
Modèles
Pagination
Désactiver le suivi du modèle
Spécifications de course
Documentation complète et accès aux API de bas niveau
Informations sur les droits d'auteur et la licence
Vous pouvez installer stream_rails comme n’importe quel autre joyau :
gem install stream_rails
ou dans votre Gemfile :
gem 'stream_rails'
Cette bibliothèque est testée et prend entièrement en charge les versions Rails suivantes :
5.0
5.2
6.0
6.1
Connectez-vous avec Github sur getstream.io et récupérez votre api_key et api_secret à partir de la configuration de votre application (écran du tableau de bord).
Ensuite, vous pouvez ajouter la configuration StreamRails dans config/initializers/stream_rails.rb
nécessite 'stream_rails'StreamRails.configure do |config| config.api_key = "VOTRE CLÉ API" config.api_secret = "VOTRE SECRET API" config.timeout = 30 # Facultatif, par défaut 3 config.location = 'us-east' # Facultatif, par défaut la configuration 'us-east'. api_hostname = 'stream-io-api.com' # Facultatif, la valeur par défaut est 'stream-io-api.com' # Si vous utilisez des noms de flux personnalisés, par exemple : timeline_flat, timeline_aggregated, # utilisez ceci, sinon omettez : config.news_feeds = { flat: "timeline_flat", agrégé : "timeline_aggregated" } # Pointez sur le groupe de flux de notifications fournissant le nom, omettez si vous n'avez pas # de flux de notifications config.notification_feed = "notification"endL'intégration ressemblera à ceci :
class Pin < ActiveRecord :: Base include StreamRails :: Activity as_activity defactivity_object self.item endend
S'il vous plaît, utilisez Sequel ~5 .
L'intégration ressemblera à ceci :
class Pin < Sequel :: Model include StreamRails :: Activity as_activity defactivity_object self.item endend
Incluez StreamRails::Activity et ajoutez as_activity au modèle que vous souhaitez intégrer à vos flux.
class Pin < ActiveRecord :: Base Appartient_to : utilisateur appartient_à : élément valide : élément, présence : vrai valide : utilisateur, présence : vrai inclut StreamRails :: Activité as_activité def activité_objet self.item endend
Chaque fois qu'une épingle est créée, elle sera stockée dans le flux de l'utilisateur qui l'a créée. Lorsqu'une instance de Pin est supprimée, le flux sera également supprimé.
Les modèles ActiveRecord sont stockés dans vos flux en tant qu'activités ; Les activités sont des objets qui racontent l'histoire d'une personne effectuant une action sur ou avec un objet. Dans sa forme la plus simple, une activité se compose d'un acteur, d'un verbe et d'un objet. Pour que cela se produise, vos modèles doivent implémenter ces méthodes :
#activity_object l'objet de l'activité (par exemple une instance de modèle AR)
#activity_actor l'acteur effectuant l'activité : cette valeur fournit également le nom et l'ID du flux auxquels l'activité sera ajoutée.
Par exemple, disons qu'un Pin était une classe polymorphe qui pouvait appartenir soit à un utilisateur (par exemple ID User : 1), soit à une entreprise (par exemple ID Company : 1). Dans ce cas, le code ci-dessous publierait le code PIN soit sur le flux user:1 , soit sur le flux company:1 en fonction de son propriétaire.
class Pin < ActiveRecord :: Base Appartient_to :owner, :polymorphic => true Appartient_to :item include StreamRails::Activity as_activity def Activity_actor self.owner end def Activity_object self.item endend
L' activity_actor est par défaut self.user
#activity_verb la représentation sous forme de chaîne du verbe (par défaut, le nom de la classe de modèle)
Voici un exemple plus complet de la classe Pin :
class Pin < ActiveRecord :: Base Appartient_to :author Appartient_to :item include StreamRails::Activity as_activity def Activity_actor self.author end def Activity_object self.item endend
Souvent, vous souhaiterez stocker plus de données que les seuls champs de base. Vous y parvenez en implémentant #activity_extra_data dans votre modèle.
class Pin < ActiveRecord::Base appartiennent_to :auteur appartient_to :item include StreamRails::Activity as_activity defactivity_extra_data {'is_retweet' => self.is_retweet} end defactivity_object self.item endend Si vous souhaitez contrôler quand créer une activité, vous devez implémenter la #activity_should_sync? méthode dans votre modèle.
class Pin < ActiveRecord :: Base Appartient_to :author Appartient_to :item include StreamRails ::Activity as_activity def Activity_should_sync? self.published fin def activité_objet self.item fin
Cela créera une activité uniquement lorsque self.published est vrai.
stream_rails est livré avec une classe Feed Manager qui facilite toutes les opérations de flux courantes. Vous pouvez obtenir une instance du gestionnaire avec StreamRails.feed_manager .
flux = StreamRails.feed_manager.get_user_feed (current_user.id)
Pour commencer, le gestionnaire dispose de 4 flux préconfigurés. Vous pouvez ajouter plus de flux si votre application le nécessite. Les flux sont divisés en trois catégories.
Le flux utilisateur stocke toutes les activités d'un utilisateur. Considérez-le comme votre page Facebook personnelle. Vous pouvez facilement obtenir ce flux auprès du gestionnaire.
flux = StreamRails.feed_manager.get_user_feed (current_user.id)
Les flux d’actualités stockent les activités des personnes que vous suivez. Il existe à la fois un fil d'actualité plat (similaire à Twitter) et un fil d'actualité agrégé (comme Facebook).
feed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat] gregated_feed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:aggregated]
Le flux de notification peut être utilisé pour créer une fonctionnalité de notification.
Ci-dessous, nous montrons un exemple de la façon dont vous pouvez lire le flux de notification.
notification_feed = StreamRails.feed_manager.get_notification_feed (current_user.id)
Par défaut, le flux de notification sera vide. Vous pouvez spécifier les utilisateurs à avertir lors de la création de votre modèle. Dans le cas d'un retweet, vous souhaiterez probablement informer l'utilisateur du tweet parent.
class Pin < ActiveRecord::Base appartiennent_to :auteur appartient_to :item include StreamRails::Activity as_activity defactivity_notify if self.is_retweet [StreamRails.feed_manager.get_notification_feed(self.parent.user_id)] end end defactivity_object self.item endend
Un autre exemple serait de suivre un utilisateur. Vous souhaiterez généralement informer l’utilisateur qui est suivi.
class Follow < ActiveRecord::Base Appartient_to :user Appartient_to :target valide :target_id, présence: vrai valide :utilisateur, présence: vrai inclut StreamRails::Activity as_activity def Activity_notify [StreamRails.feed_manager.get_notification_feed(self.target_id)] end def Activity_object fin self.target
Afin d'alimenter les fils d'actualité, vous devez informer le système des relations de suivi.
Les flux plats et agrégés de l'utilisateur actuel suivront le flux utilisateur de target_user , avec le code suivant :
StreamRails.feed_manager.follow_user(user_id, target_id)
Lorsque vous lisez des données à partir de flux, une activité d'épinglage ressemblera à ceci :
{ "actor": "Utilisateur:1", "verb": "like", "object": "Item:42" }C'est loin d'être prêt à être utilisé dans votre modèle. Nous appelons le processus de chargement des références à partir de la base de données « enrichissement ». Un exemple est présenté ci-dessous :
enricher = StreamRails::Enrich.newfeed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat]results = feed.get()['results']activities = enricher.enrich_activities(results)
Une méthode similaire appelée enrich_aggregated_activities est disponible pour les flux agrégés.
enricher = StreamRails::Enrich.newfeed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:aggregated]results = feed.get()['results']activities = enricher.enrich_aggregated_activities(results)
Si vous avez des métadonnées supplémentaires dans votre activité (en remplaçant activity_extra_data dans la classe où vous ajoutez le mixin Stream Activity), vous pouvez également enrichir les données de ce champ en procédant comme suit :
Première étape : remplacez la méthode activity_extra_data de notre mixin :
class Pin < ActiveRecord::Base include StreamRails::Activity as_activity attr_accessor :extra_data defactivity_object self.item end # remplacez cette méthode pour ajouter des métadonnées à votre activité def Activity_extra_data @extra_data endend
Nous allons maintenant créer un objet « épingle » doté d'un champ de métadonnées location . Dans cet exemple, nous aurons également une table location et un modèle, et nous configurons nos métadonnées dans le champ extra_data . Il est important que le symbole des métadonnées ainsi que la valeur des métadonnées correspondent à ce modèle. La moitié gauche de la valeur des métadonnées string:string lorsqu'elle est divisée sur : doit également correspondre au nom du modèle.
Nous devons également dire à l'enrichisseur de récupérer également des emplacements lorsqu'il parcourt nos activités.
boulder = Location.newboulder.name = "Boulder, CO"boulder.save!# indique à l'enrichisseur de faire également une recherche sur le modèle `emplacement`enricher.add_fields([:location])pin = Pin.newpin.user = @tompin .extra_data = {:location => "location:#{boulder.id}"} Lorsque nous récupérerons l'activité plus tard, le processus d'enrichissement inclura également notre modèle location , nous donnant accès aux attributs et méthodes du modèle de localisation :
lieu = activité[:location].name# Boulder, CO
Maintenant que vous avez enrichi les activités, vous pouvez les afficher dans une vue. Pour plus de commodité, nous incluons une vue de base :
<div class="container"> <div class="container-pins"> <% for activity in @activities %> <%= render_activity activity %> <% end %> </div> </div>
L'assistant de vue render_activity restituera l'activité en choisissant l' activity/_pin pour une activité d'épingle, aggregated_activity/_follow pour une activité agrégée avec suivi de verbe.
L'assistant enverra automatiquement activity à la portée locale du partiel ; des paramètres supplémentaires peuvent être envoyés, utiliser différentes mises en page et préfixer le nom
par exemple, rend l'activité partielle en utilisant la disposition small_activity :
<%= render_activity activity, :layout => "small_activity" %>
par exemple, préfixe le nom du modèle avec "notification_":
<%= render_activity activity, :prefix => "notification_" %>
par exemple, ajoute l'extra_var à la portée partielle :
<%= render_activity activity, :locals => {:extra_var => 42} %> par exemple, rend l'activité partielle en utilisant la racine partielle notifications , qui restituera le partiel avec le chemin notifications/#{ACTIVITY_VERB}
<%= render_activity activity, :partial_root => "notifications" %>
Pour une pagination simple, vous pouvez utiliser l'API stream-ruby, comme suit dans votre contrôleur :
StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat] # Renvoie un objet Stream::Feed results = feed.get(limit: 5, offset: 5)['results']
Vous pouvez désactiver le suivi du modèle (par exemple lorsque vous exécutez des tests) via StreamRails.configure
require 'stream_rails' StreamRails.enabled = false
Depuis le répertoire racine du projet :
./bin/run_tests.sh
Si nécessaire, vous pouvez également utiliser directement l'API Ruby de bas niveau. La documentation est disponible sur le site Web Stream.
Copyright (c) 2014-2021 Stream.io Inc et contributeurs individuels. Tous droits réservés.
Voir le fichier « LICENCE » pour plus d'informations sur l'historique de ce logiciel, les termes et conditions d'utilisation et une EXCLUSION DE TOUTES GARANTIES.
