twit
1.0.0
Client de l'API Twitter pour nœud
Prend en charge l'API REST et Streaming .
npm install twit var Twit = require ( 'twit' )
var T = new Twit ( {
consumer_key : '...' ,
consumer_secret : '...' ,
access_token : '...' ,
access_token_secret : '...' ,
timeout_ms : 60 * 1000 , // optional HTTP request timeout to apply to all requests.
strictSSL : true , // optional - requires SSL certificates to be valid.
} )
//
// tweet 'hello world!'
//
T . post ( 'statuses/update' , { status : 'hello world!' } , function ( err , data , response ) {
console . log ( data )
} )
//
// search twitter for all tweets containing the word 'banana' since July 11, 2011
//
T . get ( 'search/tweets' , { q : 'banana since:2011-07-11' , count : 100 } , function ( err , data , response ) {
console . log ( data )
} )
//
// get the list of user id's that follow @tolga_tezel
//
T . get ( 'followers/ids' , { screen_name : 'tolga_tezel' } , function ( err , data , response ) {
console . log ( data )
} )
//
// Twit has promise support; you can use the callback API,
// promise API, or both at the same time.
//
T . get ( 'account/verify_credentials' , { skip_status : true } )
. catch ( function ( err ) {
console . log ( 'caught error' , err . stack )
} )
. then ( function ( result ) {
// `result` is an Object with keys "data" and "resp".
// `data` and `resp` are the same objects as the ones passed
// to the callback.
// See https://github.com/ttezel/twit#tgetpath-params-callback
// for details.
console . log ( 'data' , result . data ) ;
} )
//
// retweet a tweet with id '343360866131001345'
//
T . post ( 'statuses/retweet/:id' , { id : '343360866131001345' } , function ( err , data , response ) {
console . log ( data )
} )
//
// destroy a tweet with id '343360866131001345'
//
T . post ( 'statuses/destroy/:id' , { id : '343360866131001345' } , function ( err , data , response ) {
console . log ( data )
} )
//
// get `funny` twitter users
//
T . get ( 'users/suggestions/:slug' , { slug : 'funny' } , function ( err , data , response ) {
console . log ( data )
} )
//
// post a tweet with media
//
var b64content = fs . readFileSync ( '/path/to/img' , { encoding : 'base64' } )
// first we must post the media to Twitter
T . post ( 'media/upload' , { media_data : b64content } , function ( err , data , response ) {
// now we can assign alt text to the media, for use by screen readers and
// other text-based presentations and interpreters
var mediaIdStr = data . media_id_string
var altText = "Small flowers in a planter on a sunny balcony, blossoming."
var meta_params = { media_id : mediaIdStr , alt_text : { text : altText } }
T . post ( 'media/metadata/create' , meta_params , function ( err , data , response ) {
if ( ! err ) {
// now we can reference the media and post a tweet (media will attach to the tweet)
var params = { status : 'loving life #nofilter' , media_ids : [ mediaIdStr ] }
T . post ( 'statuses/update' , params , function ( err , data , response ) {
console . log ( data )
} )
}
} )
} )
//
// post media via the chunked media upload API.
// You can then use POST statuses/update to post a tweet with the media attached as in the example above using `media_id_string`.
// Note: You can also do this yourself manually using T.post() calls if you want more fine-grained
// control over the streaming. Example: https://github.com/ttezel/twit/blob/master/tests/rest_chunked_upload.js#L20
//
var filePath = '/absolute/path/to/file.mp4'
T . postMediaChunked ( { file_path : filePath } , function ( err , data , response ) {
console . log ( data )
} )
//
// stream a sample of public statuses
//
var stream = T . stream ( 'statuses/sample' )
stream . on ( 'tweet' , function ( tweet ) {
console . log ( tweet )
} )
//
// filter the twitter public stream by the word 'mango'.
//
var stream = T . stream ( 'statuses/filter' , { track : 'mango' } )
stream . on ( 'tweet' , function ( tweet ) {
console . log ( tweet )
} )
//
// filter the public stream by the latitude/longitude bounded box of San Francisco
//
var sanFrancisco = [ '-122.75' , '36.8' , '-121.75' , '37.8' ]
var stream = T . stream ( 'statuses/filter' , { locations : sanFrancisco } )
stream . on ( 'tweet' , function ( tweet ) {
console . log ( tweet )
} )
//
// filter the public stream by english tweets containing `#apple`
//
var stream = T . stream ( 'statuses/filter' , { track : '#apple' , language : 'en' } )
stream . on ( 'tweet' , function ( tweet ) {
console . log ( tweet )
} )var T = new Twit(config) Créez une instance Twit qui peut être utilisée pour faire des demandes aux API de Twitter.
Si vous authentifiez avec le contexte de l'utilisateur, config doit être un objet du formulaire:
{
consumer_key: '...'
, consumer_secret: '...'
, access_token: '...'
, access_token_secret: '...'
}
Si vous authentifiez le contexte de l'application, config doit être un objet du formulaire:
{
consumer_key: '...'
, consumer_secret: '...'
, app_only_auth: true
}
Notez que l'application uniquement ne vous permettra pas d'effectuer des demandes aux points de terminaison de l'API nécessitant un contexte utilisateur, tel que la publication de tweets. Cependant, les points de terminaison disponibles peuvent avoir une limite de taux plus élevée.
T.get(path, [params], callback)Obtenez l'un des points de terminaison de l'API REST.
chemin
Le point de terminaison à frapper. Lorsque vous spécifiez des valeurs path , omettez le «.json» à la fin (c'est-à-dire utiliser «search / tweets» au lieu de «search / tweets.json» ).
paramètres
(Facultatifs) Paramètres pour la demande.
rappel
function (err, data, response)
data sont les données analysées reçues de Twitter.response est la [http.incomingMessage] (http://nodejs.org/api/http.httml# http_http_incomingMessage) reçu de Twitter. T.post(path, [params], callback) Publiez l'un des points de terminaison de l'API REST. Même utilisation que T.get() .
T.postMediaChunked(params, callback) Fonction d'assistance pour publier des médias via l'API Post Media / Téléchargement (Chunked). params est un objet contenant une touche file_path . file_path est le chemin d'accès absolu du fichier que vous souhaitez télécharger.
var filePath = '/absolute/path/to/file.mp4'
T . postMediaChunked ( { file_path : filePath } , function ( err , data , response ) {
console . log ( data )
} )Vous pouvez également utiliser l'API Post Media / Téléchargez via des appels t.post () si vous voulez un contrôle plus fin sur le streaming; [Voir ici pour un exemple] (https://github.com/ttezel/twit/blob/master/tests/rest_chunked_upload.js# l20).
T.getAuth()Obtenez les jetons d'authentification du client.
T.setAuth(tokens)Mettez à jour les jetons d'authentification du client.
T.stream(path, [params])Utilisez-le avec l'API de streaming.
chemin
Streaming Endpoint à frapper. Un des:
Pour une description de chaque point de terminaison en streaming, consultez les documents API Twitter.
paramètres
(Facultatifs) Paramètres pour la demande. Tous les tableaux passés dans params sont convertis en chaînes séparées par des virgules, vous permettant de faire des demandes comme:
//
// I only want to see tweets about my favorite fruits
//
// same result as doing { track: 'bananas,oranges,strawberries' }
var stream = T . stream ( 'statuses/filter' , { track : [ 'bananas' , 'oranges' , 'strawberries' ] } )
stream . on ( 'tweet' , function ( tweet ) {
//...
} ) T.stream(path, [params]) maintient la connexion vivante et renvoie un EventEmitter .
Les événements suivants sont émis:
Émis chaque fois qu'un objet est reçu dans le flux. Il s'agit d'un événement fourre-tout qui peut être utilisé pour traiter toutes les données reçues dans le flux, plutôt que d'utiliser les événements plus spécifiques documentés ci-dessous. Nouveau dans la version 2.1.0.
stream . on ( 'message' , function ( msg ) {
//...
} ) Émis chaque fois qu'un statut (tweet) entre dans le flux.
stream . on ( 'tweet' , function ( tweet ) {
//...
} ) Émis chaque fois qu'un message de suppression de statut (tweet) entre dans le flux.
stream . on ( 'delete' , function ( deleteMessage ) {
//...
} ) Émis chaque fois qu'un message de limitation entre dans le flux.
stream . on ( 'limit' , function ( limitMessage ) {
//...
} ) Émis chaque fois qu'un message de suppression de l'emplacement entre dans le flux.
stream . on ( 'scrub_geo' , function ( scrubGeoMessage ) {
//...
} ) Émis lorsqu'un message déconnecté vient de Twitter. Cela se produit si vous avez plusieurs flux connectés à l'API de Twitter. En recevant un message de déconnexion de Twitter, Twit fermera la connexion et émettra cet événement avec les détails du message reçus de Twitter.
stream . on ( 'disconnect' , function ( disconnectMessage ) {
//...
} ) Émis lorsqu'une tentative de connexion est faite sur Twitter. L'objet request HTTP est émis.
stream . on ( 'connect' , function ( request ) {
//...
} ) Émis lorsque la réponse est reçue de Twitter. L'objet response HTTP est émis.
stream . on ( 'connected' , function ( response ) {
//...
} ) Émis lorsqu'une tentative de reconnexion vers Twitter est prévue. Si Twitter a des problèmes ou si nous obtenons un taux limité, nous planifions une reconnexion en fonction des directives de reconnexion de Twitter. Les derniers objets request et response HTTP sont émis, ainsi que le temps (en millisecondes) laissé avant que la reconnexion ne se produise.
stream . on ( 'reconnect' , function ( request , response , connectInterval ) {
//...
} ) Ce message convient aux clients utilisant des connexions à largeur de bande haute, comme le Firehose. Si votre connexion prend du retard, Twitter mettra en file d'attente des messages pour vous, jusqu'à ce que votre file d'attente se remplit, à quel point ils vous déconnecteront.
stream . on ( 'warning' , function ( warning ) {
//...
} ) Émis lorsque Twitter renvoie un message status_withheld dans le flux. Cela signifie qu'un tweet a été retenu dans certains pays.
stream . on ( 'status_withheld' , function ( withheldMsg ) {
//...
} ) Émis lorsque Twitter renvoie un message user_withheld dans le flux. Cela signifie qu'un utilisateur de Twitter a été retenu dans certains pays.
stream . on ( 'user_withheld' , function ( withheldMsg ) {
//...
} ) Émis lorsque Twitter envoie le préambule ["amis"] (https://dev.twitter.com/streaming/overview/messages-types# user_stream_messsages) lors de la connexion à un flux d'utilisateur. Ce message contient une liste des amis de l'utilisateur, représenté comme un tableau d'ID utilisateur. Si le paramètre Stringify_Friend_IDS est défini, le préambule de liste des amis sera renvoyé sous forme de chaînes (au lieu des nombres).
var stream = T . stream ( 'user' , { stringify_friend_ids : true } )
stream . on ( 'friends' , function ( friendsMsg ) {
//...
} ) Émis lorsqu'un message direct est envoyé à l'utilisateur. Malheureusement, Twitter n'a pas documenté cet événement pour les flux d'utilisateurs.
stream . on ( 'direct_message' , function ( directMsg ) {
//...
} ) Émis lorsque Twitter renvoie un événement de flux d'utilisateurs. Voir les documents Twitter pour plus d'informations sur la structure de chaque événement.
stream . on ( 'user_event' , function ( eventMsg ) {
//...
} )De plus, les événements de flux d'utilisateurs suivants sont fournis pour que vous puissiez écouter:
blockedunblockedfavoriteunfavoritefollowunfollowmuteunmuteuser_updatelist_createdlist_destroyedlist_updatedlist_member_addedlist_member_removedlist_user_subscribedlist_user_unsubscribedquoted_tweetretweeted_retweetfavorited_retweetunknown_user_event (pour un événement qui ne correspond à aucun des éléments ci-dessus) stream . on ( 'favorite' , function ( event ) {
//...
} ) Émis lorsqu'une demande API ou une erreur de réponse se produit. Un objet Error est émis, avec des propriétés:
{
message : '...' , // error message
statusCode : '...' , // statusCode from Twitter
code : '...' , // error code from Twitter
twitterReply : '...' , // raw response data from Twitter
allErrors : '...' // array of errors returned from Twitter
} Appelez cette fonction sur le flux pour arrêter le streaming (ferme la connexion avec Twitter).
Appelez cette fonction pour redémarrer le flux après avoir appelé .stop() dessus. Remarque: il n'est pas nécessaire d'appeler .start() pour commencer le streaming. Twit.stream appelle .start() pour vous.
Tout dans l'API Twitter:
Allez ici pour créer une application et obtenir des informations d'identification OAuth (si vous ne l'avez pas déjà fait): https://apps.twitter.com/app/new
Vous pouvez spécifier un tableau d'empreintes digitales de certificat de confiance si vous souhaitez faire confiance à un ensemble spécifique de certificats. Lorsqu'une réponse HTTP est reçue, il est vérifié que le certificat a été signé et que l'empreinte digitale du certificat de pairs doit être l'une des valeurs que vous avez spécifiées. Par défaut, le CAS "Root" de confiance Node.js sera utilisé.
par exemple, par exemple
var twit = new Twit ( {
consumer_key : '...' ,
consumer_secret : '...' ,
access_token : '...' ,
access_token_secret : '...' ,
trusted_cert_fingerprints : [
'66:EA:47:62:D9:B1:4F:1A:AE:89:5F:68:BA:6B:8E:BB:F8:1D:BF:8E' ,
]
} ) Créez deux fichiers: config1.js et config2.js à la racine du dossier twit . Ils doivent contenir deux ensembles différents d'identification OAuth à TWIT à utiliser (deux comptes sont nécessaires pour tester les interactions). Ils devraient tous les deux ressembler à ceci:
module.exports = {
consumer_key: '...'
, consumer_secret: '...'
, access_token: '...'
, access_token_secret: '...'
}
Ensuite, exécutez les tests:
npm test
Vous pouvez également exécuter l'exemple:
node examples/rtd2.js
L'exemple est un bot Twitter nommé RTD2 écrit à l'aide de twit . RTD2 tweete sur GitHub et organise son graphique social.
FAQ
(La licence MIT)
Copyright (c) par Tolga Tezel [email protected]
L'autorisation est accordée gratuitement par la présente à toute personne qui obtient une copie de ce logiciel et des fichiers de documentation associés (le "logiciel"), pour traiter le logiciel sans restriction, y compris sans limiter les droits d'utilisation, de copier, de modifier, de fusionner , publier, distribuer, sous-licencier et / ou vendre des copies du logiciel, et pour permettre aux personnes à qui le logiciel est fourni pour le faire, sous réserve des conditions suivantes:
L'avis de droit d'auteur ci-dessus et le présent avis d'autorisation sont inclus dans toutes les copies ou des parties substantielles du logiciel.
Le logiciel est fourni "tel quel", sans garantie d'aucune sorte, express ou implicite, y compris, mais sans s'y limiter, les garanties de qualité marchande, d'adéquation à un usage particulier et de non-contrefaçon. En aucun cas, les auteurs ou les titulaires de droits d'auteur ne seront pas responsables de toute réclamation, dommage ou autre responsabilité, que ce soit dans une action de contrat, de délit ou autre, découlant de, hors du logiciel ou de l'utilisation ou d'autres transactions dans le LOGICIEL.
T.delete(...) .parser-error au lieu d'un événement error si Twitter renvoie un corps de réponse HTTP non compressé.new mot-clé; var t = Twit(config) fonctionne, et var t = new Twit(config) fonctionne également.config.trusted_cert_fingerprints .mime comme dépendance.friends Event pour friends_str Message reçu lorsqu'un flux d'utilisateur est demandé avec stringify_friend_ids=true .error pour ce cas.retweeted_retweet et favorited_retweet .T.postMediaChunked() pour le rendre facile.account/update_profile_image et account/update_profile_background_image paths.quoted_tweetmessage .connected lors de la réception de la réponse de Twitterstream.stop() et stream.start() au lieu d'émettre les événements start et stopdisconnect , ferme le flux et émet disconnect avec le message déconnecté reçu de Twittertwit POUR UTILISATION AVEC V1.1 de l'API Twitter.twit.stream() . Ne prend plus de rappel. Il revient immédiatement avec l' EventEmitter sur lequel vous pouvez écouter. La section Usage de Readme.md a été mise à jour. Lisez-le.twit.stream() a function (path, params, callback)
