Connecteur SMS
L’une des nouveautés majeures de la version 7.2 est l’introduction de l’API SMS Connector, qui est une interface flexible et standardisée utilisée pour envoyer et recevoir des messages SMS et MMS sur PBXware à l’aide de liaisons SMS personnalisées.
Cette fonctionnalité permet à nos clients de développer des applications middleware et de connecter le service SMS de PBXware aux fournisseurs SMS même s’ils ne sont actuellement pas pris en charge dans PBXware.
Avec une application middleware opérationnelle, la configuration ultérieure du PBXware est simple.
Pour créer une ligne réseau personnalisée, connectez-vous à votre interface graphique PBXware et accédez à :
- Édition Multi-Tenant:
Master Tenant > SMS > Trunks et cliquez sur Ajouter Trunk SMS.
- Édition CC/Business :
SMS > Trunks et cliquez sur Ajouter Trunk SMS.
Entrez le nom de votre nouvelle ligne SMS (c’est-à-dire le fournisseur de SMS personnalisé)
Dans le champ Fournisseur , dans la liste déroulante, sélectionnez « Personnalisé » .
Le champ URL du Webhook doit être renseigné avec l’adresse à laquelle les messages SMS/MMS envoyés via gloCOM seront envoyés.
Avec un fournisseur personnalisé sélectionné, un nouveau champ, Auth Token, apparaîtra, vous permettant de saisir le jeton utilisé pour l’authentification avec l’application distante.
Le champ Description vous permet de fournir des informations pertinentes sur cette ligne réseau qui pourraient être utiles à vous ou à d’autres administrateurs PBXware.
Une fois que tous les champs sont correctement renseignés, cliquez sur Enregistrer pour conserver les modifications et créer votre nouvelle ligne réseau personnalisée.
En supposant que l’application middleware à laquelle vous vous connectez fonctionne comme prévu, à partir de ce moment, les lignes réseau SMS personnalisées seront utilisées comme n’importe quelle autre ligne réseau SMS spécifique au fournisseur disponible sur PBXware.
Voici les champs qui vous seront présentés après avoir sélectionné Personnalisé dans le champ Fournisseur :
- Activer
Cliquez sur ce bouton bascule pour activer ou désactiver cette liaison SMS
- Nom
Affiche le nom d’un Trunk
- Fournisseur
Affiche le fournisseur sélectionné pour cette liaison. (c’est-à-dire personnalisé)
REMARQUE : Pour que l’option Personnalisé soit disponible lors de la création d’une nouvelle ligne SMS, la fonctionnalité Connecteur SMS doit être activée dans votre licence PBXware.
- URL du webhook
L’adresse de l’application middleware utilisée pour l’interface avec le fournisseur de lignes réseau personnalisées à laquelle tous les messages SMS/MMS seront envoyés.
- Jeton d’authentification
Un jeton utilisé pour l’authentification auprès de l’application middleware. Saisissez le jeton existant ou générez un nouveau jeton en appuyant sur l’icône à l’extrême droite du champ.
Fonctionnement
Envoi de messages
Le service SMS de PBXware enverra des messages SMS à l’URL du Webhook définie sous forme de requête POST.
POST {webhook_url}
Content-Type: application/json
Authorization: Bearer {auth_token}
{
"from": "string", // Sender's phone number
"to": "string", // Recipient's phone number
"text": "string", // Message content
"media_urls": ["string"] // List of URLs for multimedia attachments (MMS)
}
La passerelle SMS en écoute sur le Webhook peut alors récupérer les informations du corps JSON et envoyer une requête à n’importe quel fournisseur SMS.
La passerelle SMS doit renvoyer une réponse sous forme d’objet JSON au format suivant :
// case when sending the SMS was successful
{
"status": "success",
"message": ""
}
// case when sending the SMS was unsuccessful
{
"status": "error",
"message": "an error occured while sending the MMS"
// an error message explaining why sending failed
}
REMARQUE :
Si le code d’état de la réponse HTTP n’est pas 200, le message sera traité comme un échec.
Réception de messages
Le service SMS de PBXware reçoit des messages SMS sous forme de requête POST au format suivant :
POST /smsservice/connector
Content-Type: application/json
Authorization: Bearer {auth_token}
{
"from": "string", // Sender's phone number
"to": "string", // Recipient's phone number
"text": "string", // Message content
"media_urls": ["string"] // List of URLs for multimedia attachments (MMS)
}
Statuts de réponse :
- 200 OK : SMS reçu avec succès.
- 401 Non autorisé : l’en-tête d’autorisation était manquant ou le jeton d’authentification n’est pas valide.
- 500 : Erreur interne du serveur : plus d’informations sur l’erreur doivent être fournies dans la réponse.
Exemples
Réception de messages du service SMS de PBXware
from flask import Flask, request, jsonify
app = Flask(__name__)
def send_message_to_provider(message_data):
# The implementation of this function should be replaced with the actual
# implementation of sending the message_data to another provider
# For example, printing the received message data
print("Message received:", message_data)
return {"status": "success", "message": "Message sent successfully"}
@app.route('/messages', methods=['POST'])
def messages():
try:
# Ensure the request has a JSON content type
if request.headers['Content-Type'] != 'application/json':
return jsonify({"status": "error", "message": "Invalid content type"}), 400
# Parse the JSON data from the request body
message_data = request.get_json()
# Call the function to send the message to the provider
result = send_message_to_provider(message_data)
return jsonify(result)
except Exception as e:
# Handle any exceptions that might occur during processing
return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
# Run the server on localhost:5000
app.run(debug=True)
Envoi de messages au service SMS de PBXware
from flask import Flask, request, jsonify
import requests
app = Flask(__name__)
def parse_provider_request():
try:
# Ensure the request has a JSON content type
if request.headers['Content-Type'] != 'application/json':
raise ValueError("Invalid content type")
# Parse the JSON data from the provider's request body
provider_message_data = request.get_json()
# Create a new JSON in the specified format
formatted_message = {
"from": provider_message_data.get("sender_number", ""),
"to": provider_message_data.get("recipient_number", ""),
"text": provider_message_data.get("message_content", ""),
"media_urls": provider_message_data.get("media_urls", [])
}
return formatted_message
except Exception as e:
raise ValueError(f"Error parsing provider request: {str(e)}")
@app.route('/messages', methods=['POST'])
def messages():
try:
# Parse the provider's request using the function
formatted_message = parse_provider_request()
# Set up the headers for the outgoing request to my.pbxware.com/smsservice/connector
headers = {
'Authorization': 'Bearer YOUR_AUTH_TOKEN', # Replace with your actual Auth Token
'Content-Type': 'application/json'
}
# Send the message to the my.pbxware.com/smsservice/connector endpoint
response = requests.post('https://my.pbxware.com/smsservice/connector', json=formatted_message, headers=headers)
# Check if the request was successful (HTTP status code 2xx)
if response.ok:
return jsonify({"status": "success", "message": "Message sent successfully"})
else:
return jsonify({"status": "error", "message": f"Failed to send message. Error: {response.text}"}), response.status_code
except ValueError as ve:
# Handle parsing errors
return jsonify({"status": "error", "message": str(ve)}), 400
except Exception as e:
# Handle any other exceptions that might occur during processing
return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
# Run the server on localhost:5001
app.run(debug=True, port=5001)
Passerelle entre deux services SMS PBXware
# This Python script serves as an SMS proxy/gateway designed to facilitate communication
# between two PBXWare instances. The application acts as an intermediary for sending and
# receiving SMS messages, forwarding them from one PBXWare instance to another.
#
# Purpose:
# - Act as an SMS bridge between PBXWare instances, allowing seamless communication.
# - Handle incoming POST requests to the '/messages' endpoint, validating Bearer
# Authorization with the provided token, printing the received JSON payload, and
# forwarding the message to the specified PBXWare instance.
# - Return a JSON response with status and message fields based on the success or failure
# of the forwarding operation, utilizing the response from the receiving PBXWare instance.
#
# Command-Line Arguments:
# --listen: Specifies the host and port for the HTTP server to listen on.
# Example: --listen 127.0.0.1:5000
#
# --forward-to: Specifies the URL where incoming SMS messages will be forwarded.
# Example: --forward-to https://my.pbxware.com/smsservice/connector
#
# --auth-token: Specifies the token for Bearer Authorization, ensuring secure communication.
# Example: --auth-token my_secret_token
#
# Example Usage:
# python sms_proxy.py --listen 127.0.0.1:5000 --forward-to https://my.pbxware.com/smsservice/connector --auth-token my_secret_token
#
# Note: This script serves as an illustrative example and may need modification to suit
# specific requirements or environments.
import argparse
import json
from flask import Flask, request, abort, jsonify
import requests
app = Flask(__name__)
def parse_args():
parser = argparse.ArgumentParser(description="HTTP Server with Forwarding")
parser.add_argument("--listen", required=True, help="Host and port for HTTP server")
parser.add_argument("--forward-to", required=True, help="URL where requests will be forwarded to")
parser.add_argument("--auth-token", required=True, help="Token for Bearer Authorization")
return parser.parse_args()
def validate_auth_token(request):
auth_header = request.headers.get('Authorization')
if not auth_header or auth_header != f'Bearer {args.auth_token}':
abort(401, 'Unauthorized')
def forward_request(url, data, auth_token):
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {auth_token}'}
response = requests.post(url, data=json.dumps(data), headers=headers)
return response
@app.route('/messages', methods=['POST'])
def receive_message():
try:
validate_auth_token(request)
data = request.json
print("Received Message:")
print(json.dumps(data, indent=2))
forward_response = forward_request(args.forward_to, data, args.auth_token)
if forward_response.status_code == 200:
return jsonify({"status": "success", "message": ""}), 200
else:
return jsonify({"status": "error", "message": f"Forwarding failed with status code {forward_response.status_code}"}), 200
except Exception as e:
return jsonify({"status": "error", "message": str(e)}), 500
if __name__ == '__main__':
args = parse_args()
host, port = args.listen.split(':')
app.run(host=host, port=int(port))