Baileys
v6.7.9
Cette bibliothèque était à l'origine un projet pour le CS-2362 de l'Université d'Ashoka et n'est en aucun cas affiliée ou approuvée par WhatsApp. Utilisez à votre propre discrétion. Ne spammez pas les gens avec ça. Nous décourageons toute utilisation de stalkerware, de messagerie groupée ou automatisée.
Baileys et ses responsables ne peuvent être tenus responsables d'une mauvaise utilisation de cette application, comme indiqué dans la licence MIT. Les responsables de Baileys ne tolèrent en aucun cas l'utilisation de cette application dans des pratiques qui violent les conditions d'utilisation de WhatsApp. Les responsables de cette application font appel à la responsabilité personnelle de ses utilisateurs pour utiliser cette application de manière équitable, telle qu'elle est destinée à être utilisée.
Baileys ne nécessite pas que Selenium ou tout autre navigateur soit une interface avec WhatsApp Web, il le fait directement en utilisant un WebSocket . Ne pas exécuter Selenium ou Chromimum vous permet d'économiser environ un demi-Go de RAM :/ Baileys prend en charge l'interaction avec les versions multi-appareils et Web de WhatsApp. Merci à @pokearaujo d'avoir rédigé ses observations sur le fonctionnement de WhatsApp Multi-Device. Merci également à @Sigalor pour avoir rédigé ses observations sur le fonctionnement de WhatsApp Web et merci à @Rhymen pour la mise en œuvre go .
Le référentiel original a dû être supprimé par l'auteur original - nous poursuivons maintenant le développement dans ce référentiel ici. Il s'agit du seul référentiel officiel et il est maintenu par la communauté. Rejoignez le Discord ici
Consultez et exécutez example.ts pour voir un exemple d'utilisation de la bibliothèque. Le script couvre les cas d'utilisation les plus courants. Pour exécuter l'exemple de script, téléchargez ou clonez le dépôt, puis tapez ce qui suit dans un terminal :
cd path/to/Baileysyarnyarn exampleUtilisez la version stable :
yarn add @whiskeysockets/baileys
Utilisez la version Edge (aucune garantie de stabilité, mais derniers correctifs + fonctionnalités)
yarn add github:WhiskeySockets/Baileys
Importez ensuite votre code en utilisant :
import makeWASocket from '@whiskeysockets/baileys' FAIRE
WhatsApp fournit une API multi-appareils qui permet à Baileys de s'authentifier en tant que deuxième client WhatsApp en scannant un code QR avec WhatsApp sur votre téléphone.
import makeWASocket , { DisconnectReason } from '@whiskeysockets/baileys'
import { Boom } from '@hapi/boom'
async function connectToWhatsApp ( ) {
const sock = makeWASocket ( {
// can provide additional config here
printQRInTerminal : true
} )
sock . ev . on ( 'connection.update' , ( update ) => {
const { connection , lastDisconnect } = update
if ( connection === 'close' ) {
const shouldReconnect = ( lastDisconnect . error as Boom ) ?. output ?. statusCode !== DisconnectReason . loggedOut
console . log ( 'connection closed due to ' , lastDisconnect . error , ', reconnecting ' , shouldReconnect )
// reconnect if not logged out
if ( shouldReconnect ) {
connectToWhatsApp ( )
}
} else if ( connection === 'open' ) {
console . log ( 'opened connection' )
}
} )
sock . ev . on ( 'messages.upsert' , m => {
console . log ( JSON . stringify ( m , undefined , 2 ) )
console . log ( 'replying to' , m . messages [ 0 ] . key . remoteJid )
await sock . sendMessage ( m . messages [ 0 ] . key . remoteJid ! , { text : 'Hello there!' } )
} )
}
// run in main file
connectToWhatsApp ( )Si la connexion réussit, vous verrez un code QR imprimé sur l'écran de votre terminal, scannez-le avec WhatsApp sur votre téléphone et vous serez connecté !
Vous pouvez configurer la connexion en passant un objet SocketConfig .
La structure entière SocketConfig est mentionnée ici avec les valeurs par défaut :
type SocketConfig = {
/** the WS url to connect to WA */
waWebSocketUrl : string | URL
/** Fails the connection if the socket times out in this interval */
connectTimeoutMs : number
/** Default timeout for queries, undefined for no timeout */
defaultQueryTimeoutMs : number | undefined
/** ping-pong interval for WS connection */
keepAliveIntervalMs : number
/** proxy agent */
agent ?: Agent
/** pino logger */
logger : Logger
/** version to connect with */
version : WAVersion
/** override browser config */
browser : WABrowserDescription
/** agent used for fetch requests -- uploading/downloading media */
fetchAgent ?: Agent
/** should the QR be printed in the terminal */
printQRInTerminal : boolean
/** should events be emitted for actions done by this socket connection */
emitOwnEvents : boolean
/** provide a cache to store media, so does not have to be re-uploaded */
mediaCache ?: NodeCache
/** custom upload hosts to upload media to */
customUploadHosts : MediaConnInfo [ 'hosts' ]
/** time to wait between sending new retry requests */
retryRequestDelayMs : number
/** max msg retry count */
maxMsgRetryCount : number
/** time to wait for the generation of the next QR in ms */
qrTimeout ?: number ;
/** provide an auth state object to maintain the auth state */
auth : AuthenticationState
/** manage history processing with this control; by default will sync up everything */
shouldSyncHistoryMessage : ( msg : proto . Message . IHistorySyncNotification ) => boolean
/** transaction capability options for SignalKeyStore */
transactionOpts : TransactionCapabilityOptions
/** provide a cache to store a user's device list */
userDevicesCache ?: NodeCache
/** marks the client as online whenever the socket successfully connects */
markOnlineOnConnect : boolean
/**
* map to store the retry counts for failed messages;
* used to determine whether to retry a message or not */
msgRetryCounterMap ?: MessageRetryMap
/** width for link preview images */
linkPreviewImageThumbnailWidth : number
/** Should Baileys ask the phone for full history, will be received async */
syncFullHistory : boolean
/** Should baileys fire init queries automatically, default true */
fireInitQueries : boolean
/**
* generate a high quality link preview,
* entails uploading the jpegThumbnail to WA
* */
generateHighQualityLinkPreview : boolean
/** options for axios */
options : AxiosRequestConfig < any >
/**
* fetch a message from your store
* implement this so that messages failed to send (solves the "this message can take a while" issue) can be retried
* */
getMessage : ( key : proto . IMessageKey ) => Promise < proto . IMessage | undefined >
} const conn = makeWASocket ( {
... otherOpts ,
// can use Windows, Ubuntu here too
browser : Browsers . macOS ( 'Desktop' ) ,
syncFullHistory : true
} ) Vous ne souhaitez évidemment pas continuer à scanner le code QR à chaque fois que vous souhaitez vous connecter.
Ainsi, vous pouvez charger les informations d'identification pour vous reconnecter :
import makeWASocket , { BufferJSON , useMultiFileAuthState } from '@whiskeysockets/baileys'
import * as fs from 'fs'
// utility function to help save the auth state in a single folder
// this function serves as a good guide to help write auth & key states for SQL/no-SQL databases, which I would recommend in any production grade system
const { state , saveCreds } = await useMultiFileAuthState ( 'auth_info_baileys' )
// will use the given state to connect
// so if valid credentials are available -- it'll connect without QR
const conn = makeWASocket ( { auth : state } )
// this will be called as soon as the credentials are updated
conn . ev . on ( 'creds.update' , saveCreds ) Remarque : Lorsqu'un message est reçu/envoyé, en raison de sessions de signal nécessitant une mise à jour, les clés d'authentification ( authState.keys ) seront mises à jour. Chaque fois que cela se produit, vous devez enregistrer les clés mises à jour ( authState.keys.set() est appelé). Ne pas le faire empêchera vos messages d’atteindre le destinataire et entraînera d’autres conséquences inattendues. La fonction useMultiFileAuthState s'en charge automatiquement, mais pour toute autre implémentation sérieuse, vous devrez être très prudent avec la gestion de l'état des clés.
Baileys déclenche désormais l'événement connection.update pour vous informer que quelque chose a été mis à jour dans la connexion. Ces données ont la structure suivante :
type ConnectionState = {
/** connection is now open, connecting or closed */
connection : WAConnectionState
/** the error that caused the connection to close */
lastDisconnect ?: {
error : Error
date : Date
}
/** is this a new login */
isNewLogin ?: boolean
/** the current QR code */
qr ?: string
/** has the device received all pending notifications while it was offline */
receivedPendingNotifications ?: boolean
}Remarque : cela propose également des mises à jour du QR
Baileys utilise la syntaxe EventEmitter pour les événements. Ils sont tous bien rédigés, vous ne devriez donc pas avoir de problèmes avec un éditeur Intellisense comme VS Code.
Les événements sont typés comme mentionné ici :
export type BaileysEventMap = {
/** connection state has been updated -- WS closed, opened, connecting etc. */
'connection.update' : Partial < ConnectionState >
/** credentials updated -- some metadata, keys or something */
'creds.update' : Partial < AuthenticationCreds >
/** history sync, everything is reverse chronologically sorted */
'messaging-history.set' : {
chats : Chat [ ]
contacts : Contact [ ]
messages : WAMessage [ ]
isLatest : boolean
}
/** upsert chats */
'chats.upsert' : Chat [ ]
/** update the given chats */
'chats.update' : Partial < Chat > [ ]
/** delete chats with given ID */
'chats.delete' : string [ ]
'labels.association' : LabelAssociation
'labels.edit' : Label
/** presence of contact in a chat updated */
'presence.update' : { id : string , presences : { [ participant : string ] : PresenceData } }
'contacts.upsert' : Contact [ ]
'contacts.update' : Partial < Contact > [ ]
'messages.delete' : { keys : WAMessageKey [ ] } | { jid : string , all : true }
'messages.update' : WAMessageUpdate [ ]
'messages.media-update' : { key : WAMessageKey , media ?: { ciphertext : Uint8Array , iv : Uint8Array } , error ?: Boom } [ ]
/**
* add/update the given messages. If they were received while the connection was online,
* the update will have type: "notify"
* */
'messages.upsert' : { messages : WAMessage [ ] , type : MessageUpsertType }
/** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
'messages.reaction' : { key : WAMessageKey , reaction : proto . IReaction } [ ]
'message-receipt.update' : MessageUserReceiptUpdate [ ]
'groups.upsert' : GroupMetadata [ ]
'groups.update' : Partial < GroupMetadata > [ ]
/** apply an action to participants in a group */
'group-participants.update' : { id : string , participants : string [ ] , action : ParticipantAction }
'blocklist.set' : { blocklist : string [ ] }
'blocklist.update' : { blocklist : string [ ] , type : 'add' | 'remove' }
/** Receive an update on a call, including when the call was received, rejected, accepted */
'call' : WACallEvent [ ]
}Vous pouvez écouter ces événements comme ceci :
const sock = makeWASocket ( )
sock . ev . on ( 'messages.upsert' , ( { messages } ) => {
console . log ( 'got messages' , messages )
} ) Baileys ne propose pas de stockage de facto pour les discussions, les contacts ou les messages. Cependant, une implémentation simple en mémoire a été fournie. Le magasin écoute les mises à jour du chat, les nouveaux messages, les mises à jour des messages, etc., pour toujours disposer d'une version à jour des données.
Il peut être utilisé comme suit :
import makeWASocket , { makeInMemoryStore } from '@whiskeysockets/baileys'
// the store maintains the data of the WA connection in memory
// can be written out to a file & read from it
const store = makeInMemoryStore ( { } )
// can be read from a file
store . readFromFile ( './baileys_store.json' )
// saves the state to a file every 10s
setInterval ( ( ) => {
store . writeToFile ( './baileys_store.json' )
} , 10_000 )
const sock = makeWASocket ( { } )
// will listen from this socket
// the store can listen from a new socket once the current socket outlives its lifetime
store . bind ( sock . ev )
sock . ev . on ( 'chats.upsert' , ( ) => {
// can use "store.chats" however you want, even after the socket dies out
// "chats" => a KeyedDB instance
console . log ( 'got chats' , store . chats . all ( ) )
} )
sock . ev . on ( 'contacts.upsert' , ( ) => {
console . log ( 'got contacts' , Object . values ( store . contacts ) )
} ) Le magasin fournit également des fonctions simples telles que loadMessages qui utilisent le magasin pour accélérer la récupération des données.
Remarque : je recommande fortement de créer votre propre magasin de données, en particulier pour les connexions MD, car stocker l'intégralité de l'historique des discussions d'une personne en mémoire est un terrible gaspillage de RAM.
Envoyez tous types de messages avec une seule fonction :
import { MessageType , MessageOptions , Mimetype } from '@whiskeysockets/baileys'
const id = '[email protected]' // the WhatsApp ID
// send a simple text!
const sentMsg = await sock . sendMessage ( id , { text : 'oh hello there' } )
// send a reply messagge
const sentMsg = await sock . sendMessage ( id , { text : 'oh hello there' } , { quoted : message } )
// send a mentions message
const sentMsg = await sock . sendMessage ( id , { text : '@12345678901' , mentions : [ '[email protected]' ] } )
// send a location!
const sentMsg = await sock . sendMessage (
id ,
{ location : { degreesLatitude : 24.121231 , degreesLongitude : 55.1121221 } }
)
// send a contact!
const vcard = 'BEGIN:VCARDn' // metadata of the contact card
+ 'VERSION:3.0n'
+ 'FN:Jeff Singhn' // full name
+ 'ORG:Ashoka Uni;n' // the organization of the contact
+ 'TEL;type=CELL;type=VOICE;waid=911234567890:+91 12345 67890n' // WhatsApp ID + phone number
+ 'END:VCARD'
const sentMsg = await sock . sendMessage (
id ,
{
contacts : {
displayName : 'Jeff' ,
contacts : [ { vcard } ]
}
}
)
const reactionMessage = {
react : {
text : "?" , // use an empty string to remove the reaction
key : message . key
}
}
const sendMsg = await sock . sendMessage ( id , reactionMessage )link-preview-js comme dépendance à votre projet avec yarn add link-preview-js // send a link
const sentMsg = await sock . sendMessage ( id , { text : 'Hi, this was sent using https://github.com/adiwajshing/baileys' } )L'envoi de médias (vidéos, autocollants, images) est plus simple et plus efficace que jamais.
import { MessageType , MessageOptions , Mimetype } from '@whiskeysockets/baileys'
// Sending gifs
await sock . sendMessage (
id ,
{
video : fs . readFileSync ( "Media/ma_gif.mp4" ) ,
caption : "hello!" ,
gifPlayback : true
}
)
await sock . sendMessage (
id ,
{
video : "./Media/ma_gif.mp4" ,
caption : "hello!" ,
gifPlayback : true ,
ptv : false // if set to true, will send as a `video note`
}
)
// send an audio file
await sock . sendMessage (
id ,
{ audio : { url : "./Media/audio.mp3" } , mimetype : 'audio/mp4' }
{ url : "Media/audio.mp3" } , // can send mp3, mp4, & ogg
)id est l'identifiant WhatsApp de la personne ou du groupe à qui vous envoyez le message.[country code][phone number]@s.whatsapp.net[email protected] .[email protected] .[timestamp of creation]@broadcast .status@broadcast .jimp ou sharp en tant que dépendance dans votre projet à l'aide yarn add jimp ou yarn add sharp . Les miniatures des vidéos peuvent également être générées automatiquement, cependant, vous devez avoir installé ffmpeg sur votre système. const info : MessageOptions = {
quoted : quotedMessage , // the message you want to quote
contextInfo : { forwardingScore : 2 , isForwarded : true } , // some random context info (can show a forwarded message with this too)
timestamp : Date ( ) , // optional, if you want to manually set the timestamp of the message
caption : "hello there!" , // (for media messages) the caption to send with the media (cannot be sent with stickers though)
jpegThumbnail : "23GD#4/==" , /* (for location & media messages) has to be a base 64 encoded JPEG if you want to send a custom thumb,
or set to null if you don't want to send a thumbnail.
Do not enter this field if you want to automatically generate a thumb
*/
mimetype : Mimetype . pdf , /* (for media messages) specify the type of media (optional for all media types except documents),
import {Mimetype} from '@whiskeysockets/baileys'
*/
fileName : 'somefile.pdf' , // (for media messages) file name for the media
/* will send audio messages as voice notes, if set to true */
ptt : true ,
/** Should it send as a disappearing messages.
* By default 'chat' -- which follows the setting of the chat */
ephemeralExpiration : WA_DEFAULT_EPHEMERAL
} const msg = getMessageFromStore ( '[email protected]' , 'HSJHJWH7323HSJSJ' ) // implement this on your end
await sock . sendMessage ( '[email protected]' , { forward : msg } ) // WA forward the message! Un ensemble de clés de message doit être explicitement marqué comme lu maintenant. En multi-appareil, vous ne pouvez pas marquer un « chat » entier comme lu avec Baileys Web. Cela signifie que vous devez garder une trace des messages non lus.
const key = {
remoteJid : '[email protected]' ,
id : 'AHASHH123123AHGA' , // id of the message you want to read
participant : '[email protected]' // the ID of the user that sent the message (undefined for individual chats)
}
// pass to readMessages function
// can pass multiple keys to read multiple messages as well
await sock . readMessages ( [ key ] ) L'ID du message est l'identifiant unique du message que vous marquez comme lu. Sur un WAMessage , le messageID est accessible en utilisant messageID = message.key.id .
await sock . sendPresenceUpdate ( 'available' , id ) Cela permet à la personne/au groupe avec id de savoir si vous êtes en ligne, hors ligne, en train de taper, etc.
presence peut être l’une des suivantes :
type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused'La présence expire après environ 10 secondes.
Remarque : Dans la version multi-appareils de WhatsApp, si un client de bureau est actif, WA n'envoie pas de notifications push à l'appareil. Si vous souhaitez recevoir lesdites notifications, marquez votre client Baileys hors ligne en utilisant sock.sendPresenceUpdate('unavailable')
Si vous souhaitez sauvegarder les médias que vous avez reçus
import { writeFile } from 'fs/promises'
import { downloadMediaMessage } from '@whiskeysockets/baileys'
sock . ev . on ( 'messages.upsert' , async ( { messages } ) => {
const m = messages [ 0 ]
if ( ! m . message ) return // if there is no text or media message
const messageType = Object . keys ( m . message ) [ 0 ] // get what type of message it is -- text, image, video
// if the message is an image
if ( messageType === 'imageMessage' ) {
// download the message
const buffer = await downloadMediaMessage (
m ,
'buffer' ,
{ } ,
{
logger ,
// pass this so that baileys can request a reupload of media
// that has been deleted
reuploadRequest : sock . updateMediaMessage
}
)
// save to file
await writeFile ( './my-download.jpeg' , buffer )
}
}Remarque : WhatsApp supprime automatiquement les anciens médias de ses serveurs. Pour que l'appareil puisse accéder audit média, un nouveau téléchargement est requis par un autre appareil qui le possède. Cela peut être accompli en utilisant :
const updatedMediaMsg = await sock . updateMediaMessage ( msg ) const jid = '[email protected]' // can also be a group
const response = await sock . sendMessage ( jid , { text : 'hello!' } ) // send a message
// sends a message to delete the given message
// this deletes the message for everyone
await sock . sendMessage ( jid , { delete : response . key } ) Remarque : la suppression pour soi-même est prise en charge via chatModify (section suivante)
const jid = '[email protected]'
await sock . sendMessage ( jid , {
text : 'updated text goes here' ,
edit : response . key ,
} ) ; WA utilise une forme de communication cryptée pour envoyer des mises à jour de chat/application. Ceci a été mis en œuvre pour la plupart et vous pouvez envoyer les mises à jour suivantes :
Archiver une discussion
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
await sock . chatModify ( { archive : true , lastMessages : [ lastMsgInChat ] } , '[email protected]' )Désactiver/réactiver un chat
// mute for 8 hours
await sock . chatModify ( { mute : 8 * 60 * 60 * 1000 } , '[email protected]' , [ ] )
// unmute
await sock . chatModify ( { mute : null } , '[email protected]' , [ ] )Marquer une discussion comme lue/non lue
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
// mark it unread
await sock . chatModify ( { markRead : false , lastMessages : [ lastMsgInChat ] } , '[email protected]' )Supprimer un message pour moi
await sock . chatModify (
{ clear : { messages : [ { id : 'ATWYHDNNWU81732J' , fromMe : true , timestamp : "1654823909" } ] } } ,
'[email protected]' ,
[ ]
)Supprimer une discussion
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
await sock . chatModify ( {
delete : true ,
lastMessages : [ { key : lastMsgInChat . key , messageTimestamp : lastMsgInChat . messageTimestamp } ]
} ,
'[email protected]' )Épingler/désépingler une discussion
await sock . chatModify ( {
pin : true // or `false` to unpin
} ,
'[email protected]' )Marquer/désactiver un message
await sock . chatModify ( {
star : {
messages : [ { id : 'messageID' , fromMe : true // or `false` }],
star : true // - true: Star Message; false: Unstar Message
} } , '[email protected]' ) ;Remarque : si vous ratez l'une de vos mises à jour, WA peut vous déconnecter de tous vos appareils et vous devrez vous reconnecter.
const jid = '[email protected]' // can also be a group
// turn on disappearing messages
await sock . sendMessage (
jid ,
// this is 1 week in seconds -- how long you want messages to appear for
{ disappearingMessagesInChat : WA_DEFAULT_EPHEMERAL }
)
// will send as a disappearing message
await sock . sendMessage ( jid , { text : 'hello' } , { ephemeralExpiration : WA_DEFAULT_EPHEMERAL } )
// turn off disappearing messages
await sock . sendMessage (
jid ,
{ disappearingMessagesInChat : false }
) const id = '123456'
const [ result ] = await sock . onWhatsApp ( id )
if ( result . exists ) console . log ( ` ${ id } exists on WhatsApp, as jid: ${ result . jid } ` ) const status = await sock . fetchStatus ( "[email protected]" )
console . log ( "status: " + status ) const status = 'Hello World!'
await sock . updateProfileStatus ( status ) const name = 'My name'
await sock . updateProfileName ( name ) // for low res picture
const ppUrl = await sock . profilePictureUrl ( "[email protected]" )
console . log ( "download profile picture from: " + ppUrl )
// for high res picture
const ppUrl = await sock . profilePictureUrl ( "[email protected]" , 'image' ) const jid = '[email protected]' // can be your own too
await sock . updateProfilePicture ( jid , { url : './new-profile-picture.jpeg' } ) const jid = '[email protected]' // can be your own too
await sock . removeProfilePicture ( jid ) // the presence update is fetched and called here
sock . ev . on ( 'presence.update' , json => console . log ( json ) )
// request updates for a chat
await sock . presenceSubscribe ( "[email protected]" ) await sock . updateBlockStatus ( "[email protected]" , "block" ) // Block user
await sock . updateBlockStatus ( "[email protected]" , "unblock" ) // Unblock user const profile = await sock . getBusinessProfile ( "[email protected]" )
console . log ( "business description: " + profile . description + ", category: " + profile . category ) Bien sûr, remplacez xyz par un véritable identifiant.
Pour créer un groupe
// title & participants
const group = await sock . groupCreate ( "My Fab Group" , [ "[email protected]" , "[email protected]" ] )
console . log ( "created group with id: " + group . gid )
sock . sendMessage ( group . id , { text : 'hello there' } ) // say hello to everyone on the groupPour ajouter/supprimer des personnes à un groupe ou rétrograder/promouvoir des personnes
// id & people to add to the group (will throw error if it fails)
const response = await sock . groupParticipantsUpdate (
"[email protected]" ,
[ "[email protected]" , "[email protected]" ] ,
"add" // replace this parameter with "remove", "demote" or "promote"
)Pour changer le sujet du groupe
await sock . groupUpdateSubject ( "[email protected]" , "New Subject!" )Pour modifier la description du groupe
await sock . groupUpdateDescription ( "[email protected]" , "New Description!" )Pour modifier les paramètres du groupe
// only allow admins to send messages
await sock . groupSettingUpdate ( "[email protected]" , 'announcement' )
// allow everyone to send messages
await sock . groupSettingUpdate ( "[email protected]" , 'not_announcement' )
// allow everyone to modify the group's settings -- like display picture etc.
await sock . groupSettingUpdate ( "[email protected]" , 'unlocked' )
// only allow admins to modify the group's settings
await sock . groupSettingUpdate ( "[email protected]" , 'locked' )Pour quitter un groupe
await sock . groupLeave ( "[email protected]" ) // (will throw error if it fails)Pour obtenir le code d'invitation pour un groupe
const code = await sock . groupInviteCode ( "[email protected]" )
console . log ( "group code: " + code )Pour révoquer le code d'invitation dans un groupe
const code = await sock . groupRevokeInvite ( "[email protected]" )
console . log ( "New group code: " + code )Pour interroger les métadonnées d'un groupe
const metadata = await sock . groupMetadata ( "[email protected]" )
console . log ( metadata . id + ", title: " + metadata . subject + ", description: " + metadata . desc )Pour rejoindre le groupe en utilisant le code d'invitation
const response = await sock . groupAcceptInvite ( "xxx" )
console . log ( "joined to: " + response ) Bien sûr, remplacez xxx par le code d'invitation.
Pour obtenir des informations sur le groupe par code d'invitation
const response = await sock . groupGetInviteInfo ( "xxx" )
console . log ( "group information: " + response )Pour rejoindre le groupe en utilisant groupInviteMessage
const response = await sock . groupAcceptInviteV4 ( "[email protected]" , groupInviteMessage )
console . log ( "joined to: " + response ) Bien sûr, remplacez xxx par le code d'invitation.
Pour obtenir une demande de liste, rejoignez-nous
const response = await sock . groupRequestParticipantsList ( "[email protected]" )
console . log ( response )Pour approuver/rejeter la demande, rejoindre
const response = await sock . groupRequestParticipantsUpdate (
"[email protected]" , // id group,
[ "[email protected]" , "[email protected]" ] ,
"approve" // replace this parameter with "reject"
)
console . log ( response ) const privacySettings = await sock . fetchPrivacySettings ( true )
console . log ( "privacy settings: " + privacySettings ) const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock . updateLastSeenPrivacy ( value ) const value = 'all' // 'match_last_seen'
await sock . updateOnlinePrivacy ( value ) const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock . updateProfilePicturePrivacy ( value ) const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock . updateStatusPrivacy ( value ) const value = 'all' // 'none'
await sock . updateReadReceiptsPrivacy ( value ) const value = 'all' // 'contacts' | 'contact_blacklist'
await sock . updateGroupsAddPrivacy ( value ) const duration = 86400 // 604800 | 7776000 | 0
await sock . updateDefaultDisappearingMode ( duration ) Les messages peuvent être envoyés aux diffusions et aux histoires. vous devez ajouter les options de message suivantes dans sendMessage, comme ceci :
sock . sendMessage ( jid , { image : { url : url } , caption : caption } , { backgroundColor : backgroundColor , font : font , statusJidList : statusJidList , broadcast : true } )le corps du message peut être un ExtendedTextMessage ou imageMessage ou videoMessage ou voiceMessage
Vous pouvez ajouter backgroundColor et d'autres options dans les options de message
Broadcast : true active le mode diffusion
statusJidList : une liste de personnes que vous pouvez obtenir et que vous devez fournir, qui sont les personnes qui recevront ce message de statut.
Vous pouvez envoyer des messages à des listes de diffusion de la même manière que vous envoyez des messages à des groupes et des discussions individuelles.
À l'heure actuelle, WA Web ne prend pas en charge la création de listes de diffusion, mais vous pouvez toujours les supprimer.
Les identifiants de diffusion sont au format 12345678@broadcast
Pour interroger les destinataires et le nom d'une liste de diffusion :
const bList = await sock . getBroadcastListInfo ( "1234@broadcast" )
console . log ( `list name: ${ bList . name } , recps: ${ bList . recipients } ` ) Baileys est écrit en pensant aux fonctionnalités personnalisées. Au lieu de bifurquer le projet et de réécrire les éléments internes, vous pouvez simplement écrire vos propres extensions.
Tout d’abord, activez la journalisation des messages non traités de WhatsApp en définissant :
const sock = makeWASocket ( {
logger : P ( { level : 'debug' } ) ,
} )Cela vous permettra de voir toutes sortes de messages envoyés par WhatsApp dans la console.
Quelques exemples :
Fonctionnalité pour suivre le pourcentage de batterie de votre téléphone. Vous activez la journalisation et vous verrez un message concernant votre batterie apparaître dans la console : {"level":10,"fromMe":false,"frame":{"tag":"ib","attrs":{"from":"@s.whatsapp.net"},"content":[{"tag":"edge_routing","attrs":{},"content":[{"tag":"routing_info","attrs":{},"content":{"type":"Buffer","data":[8,2,8,5]}}]}]},"msg":"communication"}
La « trame » est ce qu'est le message reçu, elle comporte trois composantes :
tag -- de quoi parle ce cadre (par exemple, le message aura "message")attrs -- une paire clé-valeur de chaîne avec des métadonnées (contient généralement l'ID du message)content -- les données réelles (par exemple, un nœud de message contiendra le contenu réel du message)Vous pouvez enregistrer un rappel pour un événement en utilisant les éléments suivants :
// for any message with tag 'edge_routing'
sock . ws . on ( `CB:edge_routing` , ( node : BinaryNode ) => { } )
// for any message with tag 'edge_routing' and id attribute = abcd
sock . ws . on ( `CB:edge_routing,id:abcd` , ( node : BinaryNode ) => { } )
// for any message with tag 'edge_routing', id attribute = abcd & first content node routing_info
sock . ws . on ( `CB:edge_routing,id:abcd,routing_info` , ( node : BinaryNode ) => { } )De plus, ce dépôt est désormais sous licence GPL 3 puisqu'il utilise libsignal-node
