vonage php sdk core
4.10.7
Cette bibliothèque nécessite une version PHP minimale de 8.1
Il s'agit de la bibliothèque client PHP permettant d'utiliser l'API de Vonage. Pour l'utiliser, vous aurez besoin d'un compte Vonage. Inscrivez-vous gratuitement ici.
Pour utiliser la bibliothèque client, vous devez avoir créé un compte Vonage.
Pour installer la bibliothèque client PHP sur votre projet, nous vous recommandons d'utiliser Composer.
composer require vonage/clientNotez que cela pointe en fait vers une bibliothèque wrapper qui inclut un client HTTP -et- cette bibliothèque principale. Vous pouvez installer cette bibliothèque directement depuis Composer si vous le souhaitez, avec la possibilité de choisir le client HTTP utilisé par votre projet.
Vous n'avez pas besoin de cloner ce référentiel pour utiliser cette bibliothèque dans vos propres projets. Utilisez Composer pour l'installer à partir de Packagist.
Si vous débutez avec Composer, voici quelques ressources qui pourraient vous être utiles :
Si vous utilisez Composer, assurez-vous que le chargeur automatique est inclus dans le fichier d'amorçage de votre projet :
require_once " vendor/autoload.php " ;Créez un client avec votre clé API et votre secret :
$ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET )); À des fins de test, vous souhaiterez peut-être modifier l'URL à laquelle vonage/client fait des demandes de api.vonage.com vers autre chose. Vous pouvez le faire en fournissant un tableau contenant base_api_url comme deuxième paramètre lors de la création d'une instance VonageClient .
$ client = new Vonage Client (
new Vonage Client Credentials Basic ( API_KEY , API_SECRET ),
[
' base_api_url ' => ' https://example.com '
]
); Pour les API qui frappent généralement rest.nexmo.com , fournir un base_rest_url en option au constructeur modifiera ces requêtes.
Pour utiliser l'API SMS de Vonage pour envoyer un message SMS, appelez la méthode $client->sms()->send() .
Un objet message est utilisé pour créer les messages SMS. Chaque type de message peut être construit avec les paramètres requis, et une interface fluide donne accès aux paramètres facultatifs.
$ text = new Vonage SMS Message SMS ( VONAGE_TO , VONAGE_FROM , ' Test message using PHP client library ' );
$ text -> setClientRef ( ' test-message ' ); L'objet message est transmis à la méthode send :
$ response = $ client -> sms ()-> send ( $ text );Une fois envoyé, l'objet message peut être utilisé pour accéder aux données de réponse.
$ data = $ response -> current ();
echo " Sent message to " . $ data -> getTo () . " . Balance is now " . $ data -> getRemainingBalance () . PHP_EOL ; Étant donné que chaque message SMS peut être divisé en plusieurs messages, la réponse contient un objet pour chaque message généré. Vous pouvez vérifier combien de messages ont été générés à l’aide de la fonction standard count() en PHP. Si vous souhaitez obtenir le premier message, vous pouvez utiliser la méthode current() sur la réponse.
$ data = $ response -> current ();
$ data -> getRemainingBalance ();
foreach ( $ response as $ index => $ data ){
$ data -> getRemainingBalance ();
}L'exemple d'envoi contient également des exemples de travail complets.
Vous pouvez utiliser une méthode statique isGsm7() dans le code du client SMS pour déterminer s'il faut envoyer le message en utilisant le codage GSM-7 ou Unicode. Voici un exemple :
$ sms = new Vonage SMS Message SMS ( ' 123 ' , ' 456 ' , ' is this gsm7? ' );
if ( Vonage SMS Message SMS :: isGsm7 ( $ text )) {
$ sms -> setType ( ' text ' );
} else {
$ sms -> setType ( ' unicode ' );
}Les messages entrants sont envoyés à votre application sous forme de webhook. La bibliothèque client fournit un moyen de créer un objet de message entrant à partir d'un webhook :
try {
$ inbound = Vonage SMS Webhook Factory:: createFromGlobals ();
error_log ( $ inbound -> getText ());
} catch ( InvalidArgumentException $ e ) {
error_log ( ' invalid message ' );
}Vous aimerez peut-être également lire la documentation sur la signature des messages.
L'API SMS prend en charge la possibilité de signer des messages en générant et en ajoutant une signature à l'aide d'un « Secret de signature » plutôt que de votre secret API. Les algorithmes supportés sont :
md5hash1md5sha1sha256sha512Votre application et Vonage doivent se mettre d'accord sur l'algorithme à utiliser. Dans le tableau de bord, visitez la page des paramètres de votre compte et sous « Paramètres API », vous pouvez sélectionner l'algorithme à utiliser. C'est également l'endroit où vous trouverez votre « Secret de signature » (il est différent du secret de l'API).
Créez un client à l'aide de ces informations d'identification et de l'algorithme à utiliser, par exemple :
$ client = new Vonage Client ( new Vonage Client Credentials SignatureSecret ( API_KEY , SIGNATURE_SECRET , ' sha256 ' ));En utilisant ce client, vos messages API SMS seront envoyés sous forme de messages signés.
Vous aimerez peut-être également lire la documentation sur la signature des messages.
Si la signature des messages est activée pour les messages entrants, le webhook SMS inclura les champs sig , nonce et timestamp . Pour vérifier que la signature provient de Vonage, vous créez un objet Signature en utilisant les données entrantes, votre secret de signature et la méthode de signature. Utilisez ensuite la méthode check() avec la signature réelle reçue (généralement _GET['sig'] ) pour vous assurer qu'elle est correcte.
$ signature = new Vonage Client Signature ( $ _GET , SIGNATURE_SECRET , ' sha256 ' );
// is it valid? Will be true or false
$ isValid = $ signature -> check ( $ _GET [ ' sig ' ]);À l'aide de votre secret de signature et des autres paramètres fournis, la signature peut être calculée et vérifiée par rapport à la valeur de signature entrante.
L'API Messages est utilisée pour envoyer une variété de messages sortants. Les plates-formes suivantes sont actuellement prises en charge :
Chacune de ces plateformes a une catégorie différente de messages que vous pouvez envoyer (par exemple, avec WhatsApp, vous pouvez envoyer du texte, une image, de l'audio, une vidéo, un fichier ou un modèle mais pour Viber, vous ne pouvez envoyer qu'un texte ou une image) . Vous pouvez trouver tous les types de messages pouvant être envoyés sous l'espace de noms VonageMessagesChannel . La raison pour laquelle chaque type est séparé de cette façon est que la plate-forme et le type de message nécessitent des paramètres différents dans l'appel d'API.
Le VonageMessagesClient est configuré de la même manière que le client API SMS. La différence est que l'authentification peut être soit un jeton Web JSON (JWT), soit une authentification de base. Vous pouvez trouver plus d'informations sur la façon de configurer les informations d'identification de votre client dans la section « Utilisation » de ce fichier Lisez-moi.
Voici quelques exemples :
Tout d’abord, nous devons créer un nouvel objet WhatsAppText comme ceci :
$ whatsAppText = new Vonage Messages Channel WhatsApp WhatsAppText (
FROM_NUMBER ,
TO_NUMBER ,
' this is a WA text from vonage '
); Le client API Messages dispose d'une méthode, send() dans laquelle vous pouvez envoyer n'importe quel type de message fourni. Ainsi, pour envoyer ce message, le code suivant le fera, en supposant que vous ayez déjà configuré correctement votre client Vonage :
$ client -> messages ()-> send ( $ whatsAppText ); Votre réponse sera une charge utile JSON si la plage d'erreur est comprise entre 200, ou lancera une APIException pertinente si elle est comprise entre 400/500.
Certains objets Channel nécessitent plus d'arguments pour être créés. Vous pouvez voir le mappage approximatif de ces exigences en comparant les arguments du constructeur avec la documentation de l'API. Certains de ces messages acceptent des objets réutilisables personnalisés (qui se trouvent sous l'espace de noms VonageMessagesMessageObjects ). L'une d'elles est une image - voici donc un exemple de la façon d'envoyer une image Viber :
$ imageObject = Vonage Messages MessageObjects ImageObject (
' https://picsum.photos/200/300 ' ,
' image caption '
);
$ viberImage = new Vonage Messages Channel Viber ViberImage (
FROM_NUMBER ,
TO_NUMBER ,
$ imageObject
);
$ client -> messages ()-> send ( $ viberImage );L'API Verify de Vonage permet de prouver facilement qu'un utilisateur a fourni son propre numéro de téléphone lors de l'inscription, ou de mettre en œuvre une authentification à deuxième facteur lors de la connexion.
Vous pouvez démarrer un processus de vérification en utilisant un code comme celui-ci :
$ request = new Vonage Verify Request ( ' 14845551212 ' , ' My App ' );
$ response = $ client -> verify ()-> start ( $ request );
echo " Started verification with an id of: " . $ response -> getRequestId (); Une fois que l'utilisateur a saisi le code PIN qu'il a reçu, appelez la méthode check() (voir ci-dessous) avec l'ID de demande et le code PIN pour confirmer que le code PIN est correct.
Pour annuler une vérification en cours ou pour déclencher la prochaine tentative d'envoi du code de confirmation, vous pouvez transmettre soit un objet de vérification existant à la bibliothèque cliente, soit simplement utiliser un ID de requête :
$ client -> verify ()-> trigger ( ' 00e6c3377e5348cdaf567e1417c707a5 ' );
$ client -> verify ()-> cancel ( ' 00e6c3377e5348cdaf567e1417c707a5 ' );De la même manière, vérifier une vérification nécessite le code PIN fourni par l'utilisateur et l'ID de la demande :
try {
$ client -> verify ()-> check ( ' 00e6c3377e5348cdaf567e1417c707a5 ' , ' 1234 ' );
echo " Verification was successful (status: " . $ verification -> getStatus () . " ) n" ;
} catch ( Exception $ e ) {
echo " Verification failed with status " . $ e -> getCode ()
. " and error text "" . $ e -> getMessage () . ""n" ;
}Vous pouvez vérifier l'état d'une vérification ou accéder aux résultats des vérifications antérieures à l'aide d'un ID de demande. L'objet de vérification fournira alors une interface riche :
$ client -> verify ()-> search ( ' 00e6c3377e5348cdaf567e1417c707a5 ' );
echo " Codes checked for verification: " . $ verification -> getRequestId () . PHP_EOL ;
foreach ( $ verification -> getChecks () as $ check ){
echo $ check -> getDate ()-> format ( ' d-m-y ' ) . ' ' . $ check -> getStatus () . PHP_EOL ;
}L'API Verify de Vonage prend en charge SCA (Secure Customer Authentication), requis par la PSD2 (Directive sur les services de paiement) et utilisée par les applications qui ont besoin d'obtenir une confirmation des clients pour les paiements. Il comprend le bénéficiaire et le montant indiqué dans le message.
Démarrez la vérification pour un paiement comme ceci :
$ request = new Vonage Verify RequestPSD2 ( ' 14845551212 ' , ' My App ' );
$ response = $ client -> verify ()-> requestPSD2 ( $ request );
echo " Started verification with an id of: " . $ response [ ' request_id ' ]; Une fois que l'utilisateur a saisi le code PIN qu'il a reçu, appelez le point de terminaison /check avec l'ID de demande et le code PIN pour confirmer que le code PIN est correct.
Verify v2 de Vonage s'appuie davantage sur des flux de travail asynchrones via. des webhooks et des flux de travail de vérification plus personnalisables pour le développeur. Pour démarrer une vérification, vous aurez besoin du client API, qui se trouve sous l'espace de noms verify2 .
Faire une demande de vérification nécessite un canal de communication « de base » pour fournir le mode de vérification. Vous pouvez personnaliser ces interactions en ajoutant différents « workflows ». Pour chaque type de flux de travail, vous pouvez créer une classe Verify2 qui gérera le flux de travail initial pour vous. Par exemple:
$ client = new Vonage Client (
new Vonage Client Credentials Basic ( API_KEY , API_SECRET ),
);
$ smsRequest = new Vonage Verify2 Request SMSRequest ( ' TO_NUMBER ' );
$ client -> verify2 ()-> startVerification ( $ smsRequest ); L'objet SMSRequest résoudra les valeurs par défaut pour vous et créera un objet workflow par défaut pour utiliser SMS. Vous pouvez toutefois ajouter plusieurs workflows qui fonctionnent avec une logique de secours. Par exemple, si vous souhaitez créer une vérification qui tente d'obtenir un code PIN de l'utilisateur via. SMS, mais en cas de problème d'envoi de SMS vous souhaitez ajouter un repli vocal : vous pouvez l'ajouter.
$ client = new Vonage Client (
new Vonage Client Credentials Basic ( API_KEY , API_SECRET ),
);
$ smsRequest = new Vonage Verify2 Request SMSRequest ( ' TO_NUMBER ' , ' my-verification ' );
$ voiceWorkflow = new Vonage Verify2 VerifyObjects VerificationWorkflow ( Vonage Verify2 VerifyObjects VerificationWorkflow:: WORKFLOW_VOICE , ' TO_NUMBER ' );
$ smsRequest -> addWorkflow ( $ voiceWorkflow );
$ client -> verify2 ()-> startVerification ( $ smsRequest );Cela ajoute le flux de travail vocal à la demande SMS d'origine. La demande de vérification tentera de résoudre le processus dans l'ordre indiqué (en commençant par la valeur par défaut pour le type de demande).
Les types de requêtes de base sont les suivants :
SMSRequestWhatsAppRequestWhatsAppInterativeRequestEmailRequestVoiceRequestSilentAuthRequest Pour ajouter des flux de travail, vous pouvez voir les flux de travail valides disponibles sous forme de constantes dans l'objet VerificationWorkflow . Pour une meilleure expérience de développement, vous ne pouvez pas créer un flux de travail non valide en raison de la validation effectuée sur l'objet.
Pour soumettre un code, vous devrez entourer la méthode dans un try/catch en raison de la nature de l'API. Si le code est correct, la méthode renverra un true booléen. S'il échoue, il lèvera l'exception appropriée de l'API qui devra être interceptée.
$ code = ' 1234 ' ;
try {
$ client -> verify2 ()-> check ( $ code );
} catch ( Exception $ e ) {
var_dump ( $ e -> getMessage ())
}Au fur et à mesure que des événements se produisent au cours d'un flux de travail de vérification, les événements et les mises à jour seront déclenchés sous forme de webhooks. Les requêtes de serveur entrantes conformes aux normes PSR-7 peuvent être hydratées dans un objet de valeur webhook pour des interactions plus agréables. Vous pouvez également les hydrater à partir d’un tableau brut. En cas de succès, vous recevrez un objet de valeur pour le type d'événement/mise à jour. Les webhooks possibles sont :
VerifyEventVerifyStatusUpdateVerifySilentAuthUpdate // From a request object
$ verificationEvent = Vonage Verify2 Webhook Factory:: createFromRequest ( $ request );
var_dump ( $ verificationEvent -> getStatus ());
// From an array
$ payload = $ request -> getBody ()-> getContents ()
$ verificationEvent = Vonage Verify2 Webhook Factory:: createFromArray ( $ payload );
var_dump ( $ verificationEvent -> getStatus ());Vous pouvez annuler une demande si nécessaire, avant que l'utilisateur final n'ait pris une quelconque mesure.
$ requestId = ' c11236f4-00bf-4b89-84ba-88b25df97315 ' ;
$ client -> verify2 ()-> cancel ( $ requestId ); Toutes les méthodes $client->voice() nécessitent que le client soit construit avec un VonageClientCredentialsKeypair , ou un VonageClientCredentialsContainer qui inclut les informations d'identification Keypair :
$ basic = new Vonage Client Credentials Basic ( VONAGE_API_KEY , VONAGE_API_SECRET );
$ keypair = new Vonage Client Credentials Keypair (
file_get_contents ( VONAGE_APPLICATION_PRIVATE_KEY_PATH ),
VONAGE_APPLICATION_ID
);
$ client = new Vonage Client ( new Vonage Client Credentials Container ( $ basic , $ keypair )); Vous pouvez démarrer un appel à l'aide d'un objet OutboundCall :
$ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ outboundCall
-> setAnswerWebhook (
new Vonage Voice Webhook ( ' https://example.com/webhooks/answer ' )
)
-> setEventWebhook (
new Vonage Voice Webhook ( ' https://example.com/webhooks/event ' )
)
;
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall ); Si vous souhaitez que le système choisisse au hasard un numéro FROM parmi les numéros liés à une application, vous pouvez laisser le deuxième paramètre au constructeur de VonageVoiceOutboundCall et le système sélectionnera un numéro au hasard pour vous. .
SimSwap utilise les normes CAMARA afin de déterminer depuis combien de temps une carte SIM est restée à l'intérieur d'un appareil cellulaire. Cela signifie que le mécanisme d'authentification est légèrement plus complexe que les autres API. Vous aurez besoin de :
Avoir votre propre numéro d'abonné qui a été enregistré sur la plateforme de réseau mondial Vonage. Votre identifiant d'application de tableau de bord Votre clé privée
Il existe deux méthodes disponibles pour cette API : checkSimSwap et checkSimSwapDate .
Voici un exemple d'utilisation des deux :
$ credentials = new Vonage Client Credentials Gnp (
' 0777888888 ' ,
file_get_contents ( ' ./private.key ' ),
' 0dadaeb4-7c79-4d39-b4b0-5a6cc08bf537 '
);
$ client = new Vonage Client ( $ credentials );
$ swapResult = $ client -> simswap ()-> checkSimSwap ( ' 07999999999 ' , 500 );
if ( $ swapResult ) {
echo " Warning: SIM Swapped recently "
} else {
echo " SIM OK "
};
// Finding the swap date
echo $ client -> simswap ()-> checkSimSwapDate ( ' 07999999999 ' );La vérification du numéro utilise les normes API CAMARA et est utilisée pour déterminer si une demande est valide. Contrairement aux autres SDK, le SDK est divisé entre le début et la fin du processus.
Vous aurez besoin de :
Avoir votre propre numéro d'abonné qui a été enregistré sur la plateforme de réseau mondial Vonage. Votre identifiant d'application de tableau de bord Votre clé privée, téléchargée à partir du tableau de bord Vonage
buildFrontEndUrl() sur le client. Lors de l'appel, vous devrez fournir l'itinéraire vers lequel votre application est censée recevoir un rappel contenant un code unique. Vous devrez disposer d'un numéro de téléphone autorisé dans un territoire autorisé pour que cela fonctionne. Voici un exemple factice : class VerificationController extends MyFrameworkAbsractController
{
$ credentials = new Vonage Client Credentials Gnp(
' 077380777111 ' ,
file_get_contents ( ' ../private.key ' ),
' 0dadaeb4-7c79-4d39-b4b0-5a6cc08bf537 '
)
$ client = new Vonage Client ( $ credentials );
$ verifyUrl = $ client -> numberVerification ()-> buildFrontEndUrl (
' 07777777777 ' ,
' https://myapp.com/auth/numberVerify '
);
return $ this -> render ( ' verify.html.twig ' , [
' verifyLink ' => $ verifyUrl
]);
}code . La méthode renvoie un booléen de l'API. Voici un exemple : $ code = $ request -> get ( ' code ' );
$ result = $ client -> numberVerification ()-> verifyNumber (
' 09947777777 ' ,
$ code
);
if ( $ result ) {
Auth:: login ( $ request -> user ())
}
return redirect ( ' login ' );
}Cette API est utilisée pour la messagerie dans l'application et contient un large éventail de fonctionnalités et de concepts. Pour plus d'informations, consultez la documentation de l'API
$ credentials = new Vonage Client Credentials Keypair ( file_get_contents ( ' ./path-to-my-key.key ' , ' my-app-id ' ));
$ client = new Vonage Client ( $ credentials );
$ filter = new Vonage Conversation Filter ListConversationFilter ();
$ filter -> setStartDate ( ' 2018-01-01 10:00:00 ' );
$ filter -> setEndDate ( ' 2019-01-01 10:00:00 ' )
$ conversations = $ client -> conversations ()-> listConversations ( $ filter )
var_dump ( $ conversations ); $ credentials = new Vonage Client Credentials Keypair ( file_get_contents ( ' ./path-to-my-key.key ' , ' my-app-id ' ));
$ client = new Vonage Client ( $ credentials );
$ conversation = new CreateConversationRequest ( ' customer_chat ' , ' Customer Chat ' , ' https://example.com/image.png ' );
$ conversation -> setTtl ( 60 );
$ conversationNumber = new ConversationNumber ( ' 447700900000 ' );
$ conversationCallback = new ConversationCallback ( ' https://example.com/eventcallback ' );
$ conversationCallback -> setEventMask ( ' member:invited, member:joined ' );
$ conversationCallback -> setApplicationId ( ' afa393df-2c46-475b-b2d6-92da4ea05481 ' );
$ conversationCallback -> setNccoUrl ( ' https://example.com/ncco ' );
$ conversation -> setNumber ( $ conversationNumber );
$ conversation -> setConversationCallback ( $ conversationCallback );
$ response = $ this -> conversationsClient -> createConversation ( $ conversation );
var_dump ( $ response ); $ credentials = new Vonage Client Credentials Keypair ( file_get_contents ( ' ./path-to-my-key.key ' , ' my-app-id ' ));
$ client = new Vonage Client ( $ credentials );
$ filter = new ListUserConversationsFilter ();
$ filter -> setState ( ' INVITED ' );
$ filter -> setIncludeCustomData ( true );
$ filter -> setOrderBy ( ' created ' );
$ filter -> setStartDate ( ' 2018-01-01 10:00:00 ' );
$ filter -> setEndDate ( ' 2018-01-01 12:00:00 ' );
$ filter -> setPageSize ( 5 );
$ filter -> setOrder ( ' asc ' );
$ response = $ this -> conversationsClient -> listUserConversationsByUserId ( ' CON-d66d47de-5bcb-4300-94f0-0c9d4b948e9a ' );
foreach ( $ response as $ member ) {
$ members [] = $ member ;
}
var_dump ( $ members ); $ channel = Channel:: createChannel (Channel:: CHANNEL_TYPE_APP );
$ channel -> addUserFromTypes ([
' sms ' ,
' phone '
]);
$ channel -> addUserToField ( ' USR-82e028d9-9999-4f1e-8188-604b2d3471ec ' );
$ createMemberRequest = new CreateMemberRequest (
' invited ' ,
$ channel ,
' USR-82e028d9-5201-4f1e-8188-604b2d3471ec ' ,
' my_user_name ' ,
);
$ createMemberRequest -> setAudioPossible ( true );
$ createMemberRequest -> setAudioEnabled ( true );
$ createMemberRequest -> setAudioEarmuffed ( false );
$ createMemberRequest -> setAudioMuted ( false );
$ createMemberRequest -> setKnockingId ( ' 4f1e-8188 ' );
$ createMemberRequest -> setMemberIdInviting ( ' MEM-63f61863-4a51-4f6b-86e1-46edebio0391 ' );
$ createMemberRequest -> setFrom ( ' value ' );
$ response = $ this -> conversationsClient -> createMember (
$ createMemberRequest ,
' CON-63f61863-4a51-4f6b-86e1-46edebio0391 '
);
var_dump ( $ response );Les listes complètes des paramètres pour les actions NCCO sont disponibles dans la documentation de l'API vocale.
Chacun de ces exemples utilise la structure suivante pour ajouter des actions à un appel :
$ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
// ADD ACTIONS TO THE NCCO OBJECT HERE
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall ); $ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
$ ncco -> addAction ( Vonage Voice NCCO Action Record:: factory ([
' eventUrl ' => ' https://example.com/webhooks/event '
]);
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall );L'URL de votre webhook recevra une charge utile comme celle-ci :
{
"start_time": "2020-10-29T14:30:24Z",
"recording_url": "https://api.nexmo.com/v1/files/<recording-id>",
"size": 27918,
"recording_uuid": "<recording-id>",
"end_time": "2020-10-29T14:30:31Z",
"conversation_uuid": "<conversation-id>",
"timestamp": "2020-10-29T14:30:31.619Z"
}
Vous pouvez ensuite récupérer et stocker l'enregistrement comme ceci :
$recordingId = '<recording-id>';
$recordingUrl = 'https://api.nexmo.com/v1/files/' . $recordingId;
$data = $client->get($recordingUrl);
file_put_contents($recordingId.'.mp3', $data->getBody());
$ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
$ ncco -> addAction ( new Vonage Voice NCCO Action Talk ( ' This is a text to speech call from Vonage ' ));
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall ); $ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
$ ncco -> addAction ( new Vonage Voice NCCO Action Stream ( ' https://example.com/sounds/my-audio.mp3 ' ));
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall ); Prend en charge la saisie au clavier ainsi que la voix. N.-B.. l'action d'entrée doit suivre une action avec bargeIn défini sur true
$ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
$ ncco -> addAction ( Vonage Voice NCCO Action Talk:: factory ( ' Please record your name. ' ,[
' bargeIn ' => true ,
]));
$ ncco -> addAction ( Vonage Voice NCCO Action Input:: factory ([
' eventUrl ' => ' https://example.com/webhooks/event ' ,
' type ' => [
' speech ' ,
],
' speech ' => [
' endOnSilence ' => true ,
],
]));
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall );L'URL du webhook recevra une charge utile contenant l'entrée de l'utilisateur avec des indices de confiance relatifs pour l'entrée vocale.
$ outboundCall = new Vonage Voice OutboundCall (
new Vonage Voice Endpoint Phone ( ' 14843331234 ' ),
new Vonage Voice Endpoint Phone ( ' 14843335555 ' )
);
$ ncco = new NCCO ();
$ ncco -> addAction ( new Vonage Voice NCCO Action Talk ( ' We are just testing the notify function, you do not need to do anything. ' ));
$ ncco -> addAction ( new Vonage Voice NCCO Action Notify ([
' foo ' => ' bar ' ,
], new Vonage Voice Webhook ( ' https://example.com/webhooks/notify ' )));
$ outboundCall -> setNCCO ( $ ncco );
$ response = $ client -> voice ()-> createOutboundCall ( $ outboundCall );L'URL du webhook recevra une charge utile comme spécifié dans la demande.
Vous pouvez récupérer un appel à l'aide d'un objet VonageCallCall ou de l'UUID de l'appel sous forme de chaîne :
$ call = $ client -> voice ()-> get ( ' 3fd4d839-493e-4485-b2a5-ace527aacff3 ' );
echo $ call -> getDirection ();Vous pouvez également rechercher des appels à l'aide d'un filtre.
$ filter = new Vonage Voice Filter VoiceFilter ();
$ filter -> setStatus ( ' completed ' );
foreach ( $ client -> search ( $ filter ) as $ call ){
echo $ call -> getDirection ();
}Les applications sont des conteneurs de configuration. Vous pouvez en créer un en utilisant une structure de tableau :
$ application = new Vonage Application Application ();
$ application -> fromArray ([
' name ' => ' test application ' ,
' keys ' => [
' public_key ' => ' -----BEGIN PUBLIC KEY-----nMIIBIjANBgkqhkiG9w0BAQEFAAOCAnKOxjsU4pf/sMFi9N0jqcSLcjxu33Gnd/vynKnlw9SENi+UZR44GdjGdmfm1ntL1eA7IBh2HNnkYXnAwYzKJoa4eO3n0kYWekeIZawIwe/g9faFgkev+1xsOnOUNhPx2LhuLmgwWSRS4L5W851Xe3fnUQIDAQABn-----END PUBLIC KEY-----n '
],
' capabilities ' => [
' voice ' => [
' webhooks ' => [
' answer_url ' => [
' address ' => ' https://example.com/webhooks/answer ' ,
' http_method ' => ' GET ' ,
],
' event_url ' => [
' address ' => ' https://example.com/webhooks/event ' ,
' http_method ' => ' POST ' ,
],
]
],
' messages ' => [
' webhooks ' => [
' inbound_url ' => [
' address ' => ' https://example.com/webhooks/inbound ' ,
' http_method ' => ' POST '
],
' status_url ' => [
' address ' => ' https://example.com/webhooks/status ' ,
' http_method ' => ' POST '
]
]
],
' rtc ' => [
' webhooks ' => [
' event_url ' => [
' address ' => ' https://example.com/webhooks/event ' ,
' http_method ' => ' POST ' ,
],
]
],
' vbc ' => []
]
]);
$ client -> applications ()-> create ( $ application );Vous pouvez également transmettre au client un objet application :
$ a = new Vonage Application Application ();
$ a -> setName ( ' PHP Client Example ' );
$ a -> getVoiceConfig ()-> setWebhook ( ' answer_url ' , ' https://example.com/webhooks/answer ' , ' GET ' );
$ a -> getVoiceConfig ()-> setWebhook ( ' event_url ' , ' https://example.com/webhooks/event ' , ' POST ' );
$ a -> getMessagesConfig ()-> setWebhook ( ' status_url ' , ' https://example.com/webhooks/status ' , ' POST ' );
$ a -> getMessagesConfig ()-> setWebhook ( ' inbound_url ' , ' https://example.com/webhooks/inbound ' , ' POST ' );
$ a -> getRtcConfig ()-> setWebhook ( ' event_url ' , ' https://example.com/webhooks/event ' , ' POST ' );
$ a -> disableVbc ();
$ client -> applications ()-> create ( $ a );Vous pouvez parcourir toutes vos applications :
foreach ( $ client -> applications ()-> getAll () as $ application ){
echo $ application -> getName () . PHP_EOL ;
}Ou vous pouvez récupérer une application à l'aide d'une chaîne UUID ou d'un objet d'application.
$ application = $ client -> applications ()-> get ( ' 1a20a124-1775-412b-b623-e6985f4aace0 ' );Une fois que vous disposez d’un objet application, vous pouvez le modifier et l’enregistrer.
$ application = $ client -> applications ()-> get ( ' 1a20a124-1775-412b-b623-e6985f4aace0 ' );
$ application -> setName ( ' Updated Application ' );
$ client -> applications ()-> update ( $ application );Vous pouvez répertorier les numéros appartenant à votre compte et éventuellement inclure le filtrage :
search_pattern :
0 - le numéro commence par pattern1 - le numéro inclut pattern2 - le numéro se termine par pattern $ filter = new Vonage Numbers Filter OwnedNumbers ();
$ filter
-> setPattern ( 234 )
-> setSearchPattern ( Vonage Numbers Filter OwnedNumbers:: SEARCH_PATTERN_CONTAINS )
;
$ response = $ client -> numbers ()-> searchOwned ( null , $ filter ); has_application :
true - Le numéro est joint à une demandefalse - Le numéro n'est pas joint à une demande $ filter = new Vonage Numbers Filter OwnedNumbers ();
$ filter -> setHasApplication ( true );
$ response = $ client -> numbers ()-> searchOwned ( $ filter ); application_id :
$ filter = new Vonage Numbers Filter OwnedNumbers ();
$ filter -> setApplicationId ( " 66c04cea-68b2-45e4-9061-3fd847d627b8 " );
$ response = $ client -> numbers ()-> searchOwned ( $ filter );Vous pouvez rechercher des numéros disponibles à l'achat dans un pays spécifique :
$ numbers = $ client -> numbers ()-> searchAvailable ( ' US ' ); Par défaut, cela ne renverra que les 10 premiers résultats. Vous pouvez ajouter un filtre VonageNumbersFilterAvailableNumbers supplémentaire pour affiner votre recherche.
Pour acheter un numéro, vous pouvez transmettre une valeur renvoyée par la recherche de numéro :
$ numbers = $ client -> numbers ()-> searchAvailable ( ' US ' );
$ number = $ numbers -> current ();
$ client -> numbers ()-> purchase ( $ number -> getMsisdn (), $ number -> getCountry ());Ou vous pouvez spécifier le numéro et le pays manuellement :
$ client -> numbers ()-> purchase ( ' 14155550100 ' , ' US ' ); Pour mettre à jour un numéro, utilisez numbers()->update et transmettez les options de configuration que vous souhaitez modifier. Pour effacer un paramètre, transmettez une valeur vide.
$ number = $ client -> numbers ()-> get ( VONAGE_NUMBER );
$ number
-> setAppId ( ' 1a20a124-1775-412b-b623-e6985f4aace0 ' )
-> setVoiceDestination ( ' 447700900002 ' , ' tel ' )
-> setWebhook (
Vonage Number Number:: WEBHOOK_VOICE_STATUS ,
' https://example.com/webhooks/status '
)
-> setWebhook (
Vonage Number Number:: WEBHOOK_MESSAGE ,
' https://example.com/webhooks/inbound-sms '
)
;
$ client -> numbers ()-> update ( $ number );
echo " Number updated " . PHP_EOL ; Pour annuler un numéro, fournissez le msisdn :
$ client -> numbers ()-> cancel ( ' 447700900002 ' );Une API est fournie pour vous permettre de faire pivoter vos secrets d'API. Vous pouvez créer un nouveau secret (jusqu'à un maximum de deux secrets) et supprimer celui existant une fois toutes les applications mises à jour.
Pour obtenir une liste des secrets :
$ secretsCollection = $ client -> account ()-> listSecrets ( API_KEY );
/** @var VonageAccountSecret $secret */
foreach ( $ secretsCollection -> getSecrets () as $ secret ) {
echo " ID: " . $ secret -> getId () . " (created " . $ secret -> getCreatedAt () . " ) n" ;
}Vous pouvez créer un nouveau secret (les dates créées vous aideront à savoir lequel est lequel) :
$ client -> account ()-> createSecret ( API_KEY , ' awes0meNewSekret!!; ' );Et supprimez l'ancien secret (toute application utilisant encore ces informations d'identification cessera de fonctionner) :
try {
$ response = $ client -> account ()-> deleteSecret ( API_KEY , ' d0f40c7e-91f2-4fe0-8bc6-8942587b622c ' );
} catch ( Vonage Client Exception Request $ e ) {
echo $ e -> getMessage ();
} Si vous connaissez le préfixe d'un pays que vous souhaitez appeler, vous pouvez utiliser le point de terminaison prefix-pricing pour connaître les coûts d'appel de ce numéro. Chaque préfixe peut renvoyer plusieurs pays (par exemple, 1 renvoie US , CA et UM ) :
$ results = $ client -> account ()-> getPrefixPricing ( ' 1 ' );
foreach ( $ results as $ price ) {
echo $ price -> getCountryCode (). PHP_EOL ;
echo $ price -> getCountryName (). PHP_EOL ;
foreach ( $ price -> getNetworks () as $ network ) {
echo $ network -> getName () . ' :: ' . $ network -> getCode (). ' :: ' . $ network -> getPrefixPrice (). PHP_EOL ;
}
echo " ---------------- " . PHP_EOL ;
}Vérifiez combien de crédit il reste sur votre compte :
$ response = $ client -> account ()-> getBalance ();
echo round ( $ response -> getBalance (), 2 ) . " EUR n" ;Inspectez les paramètres actuels du compte :
$ response = $ client -> account ()-> getConfig ();
print_r ( $ response -> toArray ());Mettez à jour les URL de rappel par défaut pour les SMS entrants et les accusés de réception :
$ response = $ client -> account ()-> updateConfig ([
" sms_callback_url " => " http://example.com/webhooks/incoming-sms " ,
" dr_callback_url " => " http://example.com/webhooks/delivery-receipt "
]);
print_r ( $ response -> toArray ());Pour utiliser les API réseau de Vonage, vous devez être activé dans le registre réseau de Vonage.
Une fois que vous aurez un MSNDIN enregistré, vous pourrez utiliser SimSwap.
SimSwap utilise le mécanisme d'authentification de la Global Network Platform, de sorte que le flux d'autorisation est légèrement différent de celui des autres clients API. Sous le capot, le SDK gérera plusieurs appels pour que vous puissiez configurer un jeton d'accès standard CAMARA.
Voici un exemple de vérification si une carte SIM a été récemment échangée :
$ credentials = new Vonage Client Credentials Gnp (
' tel:+447700900000 ' ,
fopen ( ' ./my-private-key ' ),
' my-application-id '
);
$ client = new Vonage Client ( $ credentials );
if ( $ client -> simswap ()-> checkSimSwap ( ' 07700009999 ' , 240 )) {
echo ' Warning: SIM Swap Check Failed '
} else {
echo ' SIM Swap Check Pass '
}Et voici comment récupérer la date d'échange :
$ credentials = new Vonage Client Credentials Gnp (
' tel:+447700900000 ' ,
fopen ( ' ./my-private-key ' ),
' my-application-id '
);
$ client = new Vonage Client ( $ credentials );
$ date = $ client -> simswap ()-> checkSimSwapDate ( ' 07700009999 ' )
echo $ date;L'API Number Insights permet à un utilisateur de vérifier qu'un numéro est valide et d'en savoir plus sur la façon de l'utiliser.
Vous pouvez utiliser les méthodes basic() ou standard() (une méthode advanced() est disponible, mais il est recommandé d'utiliser l'option async pour obtenir des informations avancées), comme ceci :
try {
$ insights = $ client -> insights ()-> basic ( PHONE_NUMBER );
echo $ insights -> getNationalFormatNumber ();
} catch ( Exception $ e ) {
// for the Vonage-specific exceptions, try the `getEntity()` method for more diagnostic information
} Les données sont renvoyées dans la variable $insights dans l'exemple ci-dessus.
Pour obtenir des informations avancées, utilisez la fonctionnalité asynchrone et fournissez une URL à laquelle le webhook doit être envoyé :
try {
$ client -> insights ()-> advancedAsync ( PHONE_NUMBER , ' http://example.com/webhooks/number-insights ' );
} catch ( Exception $ e ) {
// for the Vonage-specific exceptions, try the `getEntity()` method for more diagnostic information
}Consultez la documentation pour savoir à quoi vous attendre dans le webhook entrant contenant les données que vous avez demandées.
Cette API est utilisée pour créer et configurer des sous-comptes liés à votre compte principal et transférer des crédits, des soldes et des numéros achetés entre comptes. L'API des sous-comptes est désactivée par défaut. Si vous souhaitez utiliser des sous-comptes, contactez le support pour activer l'API sur votre compte.
$ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' 34kokdf ' ;
$ subaccounts = $ client -> subaccount ()-> getSubaccounts ( $ apiKey );
var_dump ( $ subaccounts ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ payload = [
' name ' => ' sub name ' ,
' secret ' => ' s5r3fds ' ,
' use_primary_account_balance ' => false
];
$ account = new Account ();
$ account -> fromArray ( $ payload );
$ response = $ client -> subaccount ()-> createSubaccount ( $ apiKey , $ account );
var_dump ( $ response ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ subaccountKey = ' bbe6222f ' ;
$ response = $ client -> subaccount ()-> getSubaccount ( $ apiKey , $ subaccountKey );
var_dump ( $ response ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ subaccountKey = ' bbe6222f ' ;
$ payload = [
' suspended ' => true ,
' use_primary_account_balance ' => false ,
' name ' => ' Subaccount department B '
];
$ account = new Account ();
$ account -> fromArray ( $ payload );
$ response = $ client -> subaccount ()-> updateSubaccount ( $ apiKey , $ subaccountKey , $ account )
var_dump ( $ response ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ filter = new Vonage Subaccount Filter Subaccount([ ' subaccount ' => ' 35wsf5 ' ])
$ transfers = $ client -> subaccount ()-> getCreditTransfers ( $ apiKey );
var_dump ( $ transfers ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ transferRequest = ( new TransferCreditRequest ( $ apiKey ))
-> setFrom ( ' acc6111f ' )
-> setTo ( ' s5r3fds ' )
-> setAmount ( ' 123.45 ' )
-> setReference ( ' this is a credit transfer ' );
$ response = $ this -> subaccountClient -> makeCreditTransfer ( $ transferRequest ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ filter = new Vonage Subaccount Filter Subaccount ([ ' end_date ' => ' 2022-10-02 ' ]);
$ transfers = $ client -> subaccount ()-> getBalanceTransfers ( $ apiKey , $ filter ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ transferRequest = ( new TransferBalanceRequest ( $ apiKey ))
-> setFrom ( ' acc6111f ' )
-> setTo ( ' s5r3fds ' )
-> setAmount ( ' 123.45 ' )
-> setReference ( ' this is a credit transfer ' );
$ response = $ client -> subaccount ()-> makeBalanceTransfer ( $ transferRequest );
var_dump ( $ response ); $ client = new Vonage Client ( new Vonage Client Credentials Basic ( API_KEY , API_SECRET ));
$ apiKey = ' acc6111f ' ;
$ numberTransferRequest = ( new NumberTransferRequest ( $ apiKey ))
-> setFrom ( ' acc6111f ' )
-> setTo ( ' s5r3fds ' )
-> setNumber ( ' 4477705478484 ' )
-> setCountry ( ' GB ' );
$ response = $ client -> subaccount ()-> makeNumberTransfer ( $ numberTransferRequest );
var_dump ( $ response );| API | État de la version de l'API | Soutenu? |
|---|---|---|
| API de compte | Disponibilité générale | |
| API d'alertes | Disponibilité générale | |
| API d'applications | Disponibilité générale | |
| API d'audit | Bêta | |
| API de conversation | Bêta | |
| API de répartition | Bêta | |
| API des comptes externes | Bêta | |
| API multimédia | Bêta | |
| API de réunions | Disponibilité générale | |
| API de messages | Disponibilité générale | |
| API d'analyse des nombres | Disponibilité générale | |
| API de gestion des numéros | Disponibilité générale | |
| API de tarification | Disponibilité générale | |
| API de connexion proactive | Bêta | |
| API de rédaction | Disponibilité générale | |
| API de rapports | Bêta | |
| API SMS | Disponibilité générale | |
| API des sous-comptes | Disponibilité générale | |
| Vérifier l'API | Disponibilité générale | |
| Vérifier l'API (version 2) | Disponibilité générale | |
| API vocale | Disponibilité générale |
Au fil du temps, les API Vonage évoluent et ajoutent de nouvelles fonctionnalités, modifient le fonctionnement des fonctionnalités existantes, et obsolètes et suppriment les anciennes méthodes et fonctionnalités. Pour aider les développeurs à savoir quand des modifications de dépréciation sont apportées, le SDK déclenchera un avertissement E_USER_DEPRECATION . Ces avertissements n'arrêteront pas l'exécution du code, mais peuvent être gênants dans les environnements de production.
Pour vous aider, ces notifications sont supprimées par défaut. En développement, vous pouvez activer ces avertissements en passant une option de configuration supplémentaire au constructeur VonageClient , appelée show_deprecations . L'activation de cette option affichera tous les avis de dépréciation.
$ client = new Vonage Client (
new Vonage Client Credentials Basic ( API_KEY , API_SECRET ),
[
' show_deprecations ' => true
]
); Si vous remarquez un nombre excessif d'avis de dépréciation dans les environnements de production, assurez-vous que l'option de configuration est absente, ou au moins définie sur false .
unable to get local issuer certificateCertains utilisateurs rencontrent des difficultés pour effectuer des demandes en raison de l'erreur suivante :
Fatal error: Uncaught exception 'GuzzleHttpExceptionRequestException' with message 'cURL error 60: SSL certificate problem: unable to get local issuer certificate (see http://curl.haxx.se/libcurl/c/libcurl-errors.html)'
Cela est dû au fait que certaines installations PHP ne sont pas livrées avec une liste de certificats d'autorité de certification de confiance. Il s'agit d'un problème de configuration du système, non spécifique à cURL ou à Vonage.
IMPORTANT : Dans le paragraphe suivant, nous fournissons un lien vers un bundle de certificats CA. Vonage ne garantit pas la sécurité de cet ensemble et vous devez le vérifier vous-même avant d'installer un ensemble CA sur votre machine.
Pour résoudre ce problème, téléchargez une liste de certificats d'autorité de certification de confiance (par exemple, le bundle curl) et copiez-la sur votre ordinateur. Une fois cela fait, éditez php.ini et définissez le paramètre curl.cainfo :
# Linux/MacOS
curl.cainfo = "/etc/pki/tls/cacert.pem"
# Windows
curl.cainfo = "C:phpextrassslcacert.pem"
Nous autorisons l'utilisation de n'importe quel adaptateur HTTPlug ou client HTTP compatible PSR-18, vous pouvez donc créer un client avec une configuration alternative si vous en avez besoin, par exemple pour prendre en compte un proxy local, ou gérer autre chose spécifique à votre configuration.
Voici un exemple qui réduit le délai d'attente par défaut à 5 secondes pour éviter de longs délais si vous n'avez aucun itinéraire vers nos serveurs :
$ adapter_client = new Http Adapter Guzzle6 Client ( new GuzzleHttp Client ([ ' timeout ' => 5 ]));
$ vonage_client = new Vonage Client ( new Vonage Client Credentials Basic ( $ api_key , $ api_secret ), [], $ adapter_client ); Lorsque les choses tournent mal, vous recevrez une Exception . Les classes d'exception Vonage VonageClientExceptionRequest et VonageClientExceptionServer prennent en charge une méthode getEntity() supplémentaire que vous pouvez utiliser en plus de getCode() et getMessage() pour en savoir plus sur ce qui n'a pas fonctionné. L'entité renvoyée sera généralement un objet lié à l'opération ou l'objet de réponse de l'appel API.
Si vous avez une installation de package conflictuelle qui ne peut pas coexister avec notre package guzzlehttp/guzzle recommandé, vous pouvez alors installer le package vonage/client-core avec tout package satisfaisant à l'exigence php-http/client-implementation .
Voir la page Packagist pour l'implémentation client pour les options.
Notre bibliothèque client prend en charge la journalisation de la demande et de la réponse pour le débogage via des mécanismes de journalisation compatibles PSR-3. Si l'option debug est transmise au client et qu'un enregistreur compatible PSR-3 est défini dans l'usine de services de notre client, nous utiliserons l'enregistreur à des fins de débogage.
$ client = new Vonage Client ( new Vonage Client Credentials Basic ( ' abcd1234 ' , ' s3cr3tk3y ' ), [ ' debug ' => true ]);
$ logger = new Monolog Logger ( ' test ' );
$ logger -> pushHandler ( new Monolog Handler StreamHandler ( __DIR__ . ' /log.txt ' , Monolog Logger:: DEBUG ));
$ client -> getFactory ()-> set ( PSR Log LoggerInterface::class, $ logger );L'ACTIVATION DE LA JOURNALISATION DU DÉBOGAGE A LE POTENTIEL D'ENREGISTRER DES INFORMATIONS SENSIBLES, NE PAS ACTIVER EN PRODUCTION
Cette bibliothèque dispose d'une suite de tests complète conçue pour être exécutée avec PHPUnit.
Pour exécuter, utilisez composer :
composer test
Remarque : cette suite de tests est volumineuse et son exécution peut nécessiter une quantité considérable de mémoire. Si vous rencontrez l'erreur « trop de fichiers ouverts » sous MacOS ou Linux, il existe un hack pour augmenter le nombre de pointeurs de fichiers autorisés. Augmentez le nombre de fichiers pouvant être ouverts en entrant ce qui suit sur la ligne de commande (10 240 est le nombre maximum de pointeurs que MacOS ouvrira actuellement) :
ulimit -n 10240
Cette bibliothèque est activement développée et nous aimons avoir de vos nouvelles ! N'hésitez pas à créer un problème ou à ouvrir une pull request avec vos questions, commentaires, suggestions et retours.
